home *** CD-ROM | disk | FTP | other *** search
/ Software Vault: The Games Collection 1 / software vault.zip / software vault / CDR10 / TGE129C.ZIP / SOURCE / TGE.C < prev    next >
C/C++ Source or Header  |  1993-08-20  |  91KB  |  2,602 lines
  1. /*****************************************************************************
  2. *       The Graphics Engine version 1.29ßC                                   *
  3. *                                                                            *
  4. *       The Graphics Engine code and documentation are Copyright (c) 1993    *
  5. *       by Matthew Hildebrand.                                               *
  6. *                                                                            *
  7. *       Unauthorised usage or modification of any or all of The Graphics     *
  8. *       Engine is strictly prohibited.                                       *
  9. *****************************************************************************/
  10.  
  11. /* This copyright notice may not be removed and must remain intact */
  12. static char copyright[] = "The Graphics Engine 1.29ßC -- Copyright (c) 1993 by Matthew Hildebrand";
  13.  
  14.  
  15. /* Guess what... this file must be compiled with the large or huge model. */
  16. #if !defined(__LARGE__) && !defined(__HUGE__) && !defined(M_I86LM)
  17.   #error This module must be compiled with the large or huge model.
  18. #endif
  19.  
  20.  
  21. #include <alloc.h>
  22. #include <dos.h>
  23. #include <math.h>
  24. #include <mem.h>
  25. #include <stdio.h>
  26. #include <stdlib.h>
  27. #include "tge.h"
  28.  
  29.  
  30. /* #define macros needed only for TGE.C */
  31. #define INADDR        (TGEsys->inAddr)
  32. #define OUTADDR        (TGEsys->outAddr)
  33. #define SCRADDR        (TGEsys->scrAddr)
  34. #define INSCREENWIDE    (TGEsys->inScreenWide)
  35. #define OUTSCREENWIDE    (TGEsys->outScreenWide)
  36. #define SCREEN        1
  37. #define MEMORY        2
  38.  
  39.  
  40.  
  41. /******
  42. ******* Function prototypes
  43. ******/
  44.  
  45. static void far TGE_deInitGraphics(void);
  46. static void far TGE_setPaletteReg(unsigned palReg, unsigned char red, unsigned char blue, unsigned char green);
  47. static void far TGE_getPaletteReg(unsigned palReg, unsigned char *red, unsigned char *blue, unsigned char *green);
  48. static void far TGE_setBlockPalette(unsigned firstReg, unsigned numRegs, void far *data);
  49. static void far TGE_getBlockPalette(unsigned firstReg, unsigned numRegs, void far *data);
  50. static unsigned far TGE_colourCloseTo(unsigned char red, unsigned char green, unsigned    char blue);
  51. static unsigned far TGE_colourCloseToX(unsigned char red, unsigned char green, unsigned    char blue, unsigned colourExclude);
  52. static unsigned long far TGE_imageSize(int ulx, int uly, int lrx, int lry);
  53. static unsigned long far TGE_imageSizeDim(unsigned wide, unsigned deep);
  54. static void huge TGE_getImage(int ulx, int uly, int lrx, int lry, void far *image);
  55. static void far TGE_getLine(int lineNum, int xOff, int lineLen, void far *buf);
  56. static unsigned far TGE_getPixel_scr(int x, int y);
  57. static unsigned far TGE_getPixel_mem(int x, int y);
  58. static void huge TGE_putImage(int x, int y, void far *image);
  59. static void huge TGE_putImageInv(int x, int y, void far *image);
  60. static void far TGE_putLine(int lineNum, int xOff, int lineLen, void far *buf);
  61. static void far TGE_putLineInv(int lineNum, int xOff, int lineLen, void far *buf);
  62. static void far TGE_putPixel_scr_copy(int x, int y, unsigned colour);
  63. static void far TGE_putPixel_scr_and (int x, int y, unsigned colour);
  64. static void far TGE_putPixel_scr_not (int x, int y, unsigned colour);
  65. static void far TGE_putPixel_scr_or  (int x, int y, unsigned colour);
  66. static void far TGE_putPixel_scr_xor (int x, int y, unsigned colour);
  67. static void far TGE_putPixel_mem_copy(int x, int y, unsigned colour);
  68. static void far TGE_putPixel_mem_and (int x, int y, unsigned colour);
  69. static void far TGE_putPixel_mem_not (int x, int y, unsigned colour);
  70. static void far TGE_putPixel_mem_or  (int x, int y, unsigned colour);
  71. static void far TGE_putPixel_mem_xor (int x, int y, unsigned colour);
  72. static void far TGE_line(int x1, int y1, int x2, int y2, unsigned colour);
  73. static void far TGE_horizLine(int y, int x1, int x2, unsigned colour);
  74. static void far TGE_vertLine(int x, int y1, int y2, unsigned colour);
  75. static void far TGE_drawRect(int ulx, int uly, int lrx, int lry, unsigned colour);
  76. static void far TGE_filledRect(int ulx, int uly, int lrx, int lry, unsigned colour);
  77. static void far TGE_clearGraphics(unsigned colour);
  78. static void far TGE_ellipse(int xc, int yc, int wide, int deep, unsigned colour);
  79. static void far TGE_filledEllipse(int xc, int yc, int wide, int deep, unsigned colour);
  80. static void far TGE_circle(int x, int y, int radius, unsigned colour);
  81. static void far TGE_filledCircle(int x, int y, int radius, unsigned colour);
  82. static void far TGE_fillRegion(int x, int y, unsigned colour);
  83.  
  84. static void* near forceOffset(void far *p);
  85. static void near setupInfo(struct GraphDrv far *grDrv);
  86. static void near set4Pixels(int x, int y, int xc, int yc, unsigned colour);
  87. static void near fill4Pixels(int x, int y, int xc, int yc, unsigned colour);
  88. static void near setInputFunctions(int memOrScreen);
  89. static void near setOutputFunctions(int memOrScreen, int writeMode);
  90. static unsigned char far* near inPixelAddr(int x, int y);
  91. static unsigned char far* near outPixelAddr(int x, int y);
  92.  
  93.  
  94. static int curOutputMode = TGE_COPY_PUT;
  95. static int curOutputDest = SCREEN;
  96. static void far *drvAddr = NULL;
  97. struct GraphDrv far *TGEsys = NULL;
  98.  
  99.  
  100. /*****
  101. ****** Routines to load a graphics driver from disk.
  102. *****/
  103.  
  104. int TGE_loadGraphDriver(char *filename)
  105. {
  106.   struct GraphDrv far *grDrv = NULL;
  107.   FILE *inFile;
  108.   long fileLen;
  109.   char signature[4];
  110.  
  111.  
  112.   /* Outsmart smart linkers; force copyright string to be in EXE file */
  113.   copyright[0] = 'T';                /* dummy write */
  114.  
  115.  
  116.   /* Open the input file */
  117.   if ((inFile=fopen(filename,"rb")) == NULL)    /* open the file */
  118.     return (TGE_OPEN_ERR);
  119.  
  120.  
  121.   /* Get file size */
  122.   fseek(inFile, 0, SEEK_END);            /* seek to end of file */
  123.   fileLen = ftell(inFile);            /* get current position */
  124.   rewind(inFile);                /* seek to start of file */
  125.  
  126.  
  127.   /* Parse the file header */
  128.   if (!fread(signature, 1, 4, inFile))        /* read signature string */
  129.   {
  130.     fclose(inFile);
  131.     return (TGE_FORMAT_ERR);
  132.   }
  133.  
  134.   if (memcmp(signature, "TGE3", 4))           /* check signature string */
  135.   {
  136.     fclose(inFile);
  137.     return (TGE_FORMAT_ERR);
  138.   }
  139.  
  140.  
  141.   /* Allocate memory for the driver */
  142.   fileLen -= 4;                    /* remove signature size */
  143.   if (((void*)drvAddr=farmalloc(fileLen+15L)) == NULL)    /* grab some RAM */
  144.   {
  145.     fclose(inFile);
  146.     return (TGE_ALLOC_ERR);
  147.   }
  148.  
  149.   (void*)grDrv = forceOffset(drvAddr);        /* force to XXXX:0004 */
  150.  
  151.  
  152.   /* Read in the body of the driver */
  153.   if (fread(grDrv, 1, (unsigned)fileLen, inFile) != (unsigned)fileLen)
  154.   {
  155.     fclose(inFile);
  156.     farfree(drvAddr);
  157.     return (TGE_FILE_ERR);
  158.   }
  159.  
  160.  
  161.   /* Everything is loaded properly; now set up for program use */
  162.   TGEsys = grDrv;                /* set global variable */
  163.   setupInfo(grDrv);                /* setup function pointers */
  164.   fclose(inFile);                /* close input file */
  165.  
  166.   return (TGE_SUCCESS);                /* return success code */
  167. }
  168.  
  169.  
  170. /***
  171. **** Force a pointer to the form XXXX:0004
  172. ***/
  173. static void* near forceOffset(void far *p)
  174. {
  175.   void huge *temp = (void huge*)p;
  176.  
  177.   if (FP_OFF(temp) == 4)
  178.     return ((void far*)temp);
  179.   else if (FP_OFF(temp) > 4)
  180.     return (MK_FP(FP_SEG(temp)+1, 4));
  181.   else
  182.     return (MK_FP(FP_SEG(temp), 4));
  183. }
  184.  
  185.  
  186. /***
  187. **** Set up function pointers once a driver has been loaded
  188. ***/
  189. static void near setupInfo(struct GraphDrv far *grDrv)
  190. {
  191.   register unsigned seg = FP_SEG(grDrv);
  192.  
  193.   /* initGraphics must always be present */
  194.   (void*)grDrv->_initGraphics = MK_FP(seg, FP_OFF(grDrv->_initGraphics));
  195.  
  196.  
  197.   /* Set up non-I/O functions */
  198.   if (FP_OFF(grDrv->_deInitGraphics))        /* deInitGraphics */
  199.     (void*)grDrv->_deInitGraphics = MK_FP(seg, FP_OFF(grDrv->_deInitGraphics));
  200.   else
  201.     grDrv->_deInitGraphics = TGE_deInitGraphics;
  202.  
  203.   if (FP_OFF(grDrv->_setPaletteReg))        /* setPaletteReg */
  204.     (void*)grDrv->_setPaletteReg = MK_FP(seg, FP_OFF(grDrv->_setPaletteReg));
  205.   else
  206.     grDrv->_setPaletteReg = TGE_setPaletteReg;
  207.  
  208.   if (FP_OFF(grDrv->_getPaletteReg))        /* getPaletteReg */
  209.     (void*)grDrv->_getPaletteReg = MK_FP(seg, FP_OFF(grDrv->_getPaletteReg));
  210.   else
  211.     grDrv->_getPaletteReg = TGE_getPaletteReg;
  212.  
  213.   if (FP_OFF(grDrv->_setBlockPalette))        /* setBlockPalette */
  214.     (void*)grDrv->_setBlockPalette = MK_FP(seg, FP_OFF(grDrv->_setBlockPalette));
  215.   else
  216.     grDrv->_setBlockPalette = TGE_setBlockPalette;
  217.  
  218.   if (FP_OFF(grDrv->_getBlockPalette))        /* getBlockPalette */
  219.     (void*)grDrv->_getBlockPalette = MK_FP(seg, FP_OFF(grDrv->_getBlockPalette));
  220.   else
  221.     grDrv->_getBlockPalette = TGE_getBlockPalette;
  222.  
  223.   if (FP_OFF(grDrv->_colourCloseTo))        /* colourCloseTo */
  224.     (void*)grDrv->_colourCloseTo = MK_FP(seg, FP_OFF(grDrv->_colourCloseTo));
  225.   else
  226.     grDrv->_colourCloseTo = TGE_colourCloseTo;
  227.  
  228.   if (FP_OFF(grDrv->_colourCloseToX))        /* colourCloseToX */
  229.     (void*)grDrv->_colourCloseToX = MK_FP(seg, FP_OFF(grDrv->_colourCloseToX));
  230.   else
  231.     grDrv->_colourCloseToX = TGE_colourCloseToX;
  232.  
  233.   if (FP_OFF(grDrv->_imageSize))        /* imageSize */
  234.     (void*)grDrv->_imageSize = MK_FP(seg, FP_OFF(grDrv->_imageSize));
  235.   else
  236.     grDrv->_imageSize = TGE_imageSize;
  237.  
  238.   if (FP_OFF(grDrv->_imageSizeDim))        /* imageSizeDim */
  239.     (void*)grDrv->_imageSizeDim = MK_FP(seg, FP_OFF(grDrv->_imageSizeDim));
  240.   else
  241.     grDrv->_imageSizeDim = TGE_imageSizeDim;
  242.  
  243.  
  244.   /* Set up input functions */
  245.   if (FP_OFF(grDrv->_getImage_scr))        /* getImage_scr */
  246.     (void*)grDrv->_getImage_scr = MK_FP(seg, FP_OFF(grDrv->_getImage_scr));
  247.   else
  248.     grDrv->_getImage_scr = TGE_getImage;
  249.  
  250.   if (FP_OFF(grDrv->_getImage_mem))        /* getImage_mem */
  251.     (void*)grDrv->_getImage_mem = MK_FP(seg, FP_OFF(grDrv->_getImage_mem));
  252.   else
  253.     grDrv->_getImage_mem = TGE_getImage;
  254.  
  255.   if (FP_OFF(grDrv->_getLine_scr))        /* getLine_scr */
  256.     (void*)grDrv->_getLine_scr = MK_FP(seg, FP_OFF(grDrv->_getLine_scr));
  257.   else
  258.     grDrv->_getLine_scr = TGE_getLine;
  259.  
  260.   if (FP_OFF(grDrv->_getLine_mem))        /* getLine_mem */
  261.     (void*)grDrv->_getLine_mem = MK_FP(seg, FP_OFF(grDrv->_getLine_mem));
  262.   else
  263.     grDrv->_getLine_mem = TGE_getLine;
  264.  
  265.   if (FP_OFF(grDrv->_getPixel_scr))        /* getPixel_scr */
  266.     (void*)grDrv->_getPixel_scr = MK_FP(seg, FP_OFF(grDrv->_getPixel_scr));
  267.   else
  268.     grDrv->_getPixel_scr = TGE_getPixel_scr;
  269.  
  270.   if (FP_OFF(grDrv->_getPixel_mem))        /* getPixel_mem */
  271.     (void*)grDrv->_getPixel_mem = MK_FP(seg, FP_OFF(grDrv->_getPixel_mem));
  272.   else
  273.     grDrv->_getPixel_mem = TGE_getPixel_mem;
  274.  
  275.  
  276.   /* Set up output functions */
  277.   if (FP_OFF(grDrv->_putImage_scr_copy))    /* putImage_scr_copy */
  278.     (void*)grDrv->_putImage_scr_copy = MK_FP(seg, FP_OFF(grDrv->_putImage_scr_copy));
  279.   else
  280.     grDrv->_putImage_scr_copy = TGE_putImage;
  281.   if (FP_OFF(grDrv->_putImage_scr_and))        /* putImage_scr_and */
  282.     (void*)grDrv->_putImage_scr_and = MK_FP(seg, FP_OFF(grDrv->_putImage_scr_and));
  283.   else
  284.     grDrv->_putImage_scr_and = TGE_putImage;
  285.   if (FP_OFF(grDrv->_putImage_scr_not))        /* putImage_scr_not */
  286.     (void*)grDrv->_putImage_scr_not = MK_FP(seg, FP_OFF(grDrv->_putImage_scr_not));
  287.   else
  288.     grDrv->_putImage_scr_not = TGE_putImage;
  289.   if (FP_OFF(grDrv->_putImage_scr_or))        /* putImage_scr_or */
  290.     (void*)grDrv->_putImage_scr_or = MK_FP(seg, FP_OFF(grDrv->_putImage_scr_or));
  291.   else
  292.     grDrv->_putImage_scr_or = TGE_putImage;
  293.   if (FP_OFF(grDrv->_putImage_scr_xor))        /* putImage_scr_xor */
  294.     (void*)grDrv->_putImage_scr_xor = MK_FP(seg, FP_OFF(grDrv->_putImage_scr_xor));
  295.   else
  296.     grDrv->_putImage_scr_xor = TGE_putImage;
  297.   if (FP_OFF(grDrv->_putImage_mem_copy))    /* putImage_mem_copy */
  298.     (void*)grDrv->_putImage_mem_copy = MK_FP(seg, FP_OFF(grDrv->_putImage_mem_copy));
  299.   else
  300.     grDrv->_putImage_mem_copy = TGE_putImage;
  301.   if (FP_OFF(grDrv->_putImage_mem_and))        /* putImage_mem_and */
  302.     (void*)grDrv->_putImage_mem_and = MK_FP(seg, FP_OFF(grDrv->_putImage_mem_and));
  303.   else
  304.     grDrv->_putImage_mem_and = TGE_putImage;
  305.   if (FP_OFF(grDrv->_putImage_mem_not))        /* putImage_mem_not */
  306.     (void*)grDrv->_putImage_mem_not = MK_FP(seg, FP_OFF(grDrv->_putImage_mem_not));
  307.   else
  308.     grDrv->_putImage_mem_not = TGE_putImage;
  309.   if (FP_OFF(grDrv->_putImage_mem_or))        /* putImage_mem_or */
  310.     (void*)grDrv->_putImage_mem_or = MK_FP(seg, FP_OFF(grDrv->_putImage_mem_or));
  311.   else
  312.     grDrv->_putImage_mem_or = TGE_putImage;
  313.   if (FP_OFF(grDrv->_putImage_mem_xor))        /* putImage_mem_xor */
  314.     (void*)grDrv->_putImage_mem_xor = MK_FP(seg, FP_OFF(grDrv->_putImage_mem_xor));
  315.   else
  316.     grDrv->_putImage_mem_xor = TGE_putImage;
  317.  
  318.   if (FP_OFF(grDrv->_putImageInv_scr_copy))    /* putImageInv_scr_copy */
  319.     (void*)grDrv->_putImageInv_scr_copy = MK_FP(seg, FP_OFF(grDrv->_putImageInv_scr_copy));
  320.   else
  321.     grDrv->_putImageInv_scr_copy = TGE_putImageInv;
  322.   if (FP_OFF(grDrv->_putImageInv_scr_and))    /* putImageInv_scr_and */
  323.     (void*)grDrv->_putImageInv_scr_and = MK_FP(seg, FP_OFF(grDrv->_putImageInv_scr_and));
  324.   else
  325.     grDrv->_putImageInv_scr_and = TGE_putImageInv;
  326.   if (FP_OFF(grDrv->_putImageInv_scr_not))    /* putImageInv_scr_not */
  327.     (void*)grDrv->_putImageInv_scr_not = MK_FP(seg, FP_OFF(grDrv->_putImageInv_scr_not));
  328.   else
  329.     grDrv->_putImageInv_scr_not = TGE_putImageInv;
  330.   if (FP_OFF(grDrv->_putImageInv_scr_or))    /* putImageInv_scr_or */
  331.     (void*)grDrv->_putImageInv_scr_or = MK_FP(seg, FP_OFF(grDrv->_putImageInv_scr_or));
  332.   else
  333.     grDrv->_putImageInv_scr_or = TGE_putImageInv;
  334.   if (FP_OFF(grDrv->_putImageInv_scr_xor))    /* putImageInv_scr_xor */
  335.     (void*)grDrv->_putImageInv_scr_xor = MK_FP(seg, FP_OFF(grDrv->_putImageInv_scr_xor));
  336.   else
  337.     grDrv->_putImageInv_scr_xor = TGE_putImageInv;
  338.   if (FP_OFF(grDrv->_putImageInv_mem_copy))    /* putImageInv_mem_copy */
  339.     (void*)grDrv->_putImageInv_mem_copy = MK_FP(seg, FP_OFF(grDrv->_putImageInv_mem_copy));
  340.   else
  341.     grDrv->_putImageInv_mem_copy = TGE_putImageInv;
  342.   if (FP_OFF(grDrv->_putImageInv_mem_and))    /* putImageInv_mem_and */
  343.     (void*)grDrv->_putImageInv_mem_and = MK_FP(seg, FP_OFF(grDrv->_putImageInv_mem_and));
  344.   else
  345.     grDrv->_putImageInv_mem_and = TGE_putImageInv;
  346.   if (FP_OFF(grDrv->_putImageInv_mem_not))    /* putImageInv_mem_not */
  347.     (void*)grDrv->_putImageInv_mem_not = MK_FP(seg, FP_OFF(grDrv->_putImageInv_mem_not));
  348.   else
  349.     grDrv->_putImageInv_mem_not = TGE_putImageInv;
  350.   if (FP_OFF(grDrv->_putImageInv_mem_or))    /* putImageInv_mem_or */
  351.     (void*)grDrv->_putImageInv_mem_or = MK_FP(seg, FP_OFF(grDrv->_putImageInv_mem_or));
  352.   else
  353.     grDrv->_putImageInv_mem_or = TGE_putImageInv;
  354.   if (FP_OFF(grDrv->_putImageInv_mem_xor))    /* putImageInv_mem_xor */
  355.     (void*)grDrv->_putImageInv_mem_xor = MK_FP(seg, FP_OFF(grDrv->_putImageInv_mem_xor));
  356.   else
  357.     grDrv->_putImageInv_mem_xor = TGE_putImageInv;
  358.  
  359.   if (FP_OFF(grDrv->_putLine_scr_copy))        /* putLine_scr_copy */
  360.     (void*)grDrv->_putLine_scr_copy = MK_FP(seg, FP_OFF(grDrv->_putLine_scr_copy));
  361.   else
  362.     grDrv->_putLine_scr_copy = TGE_putLine;
  363.   if (FP_OFF(grDrv->_putLine_scr_and))        /* putLine_scr_and */
  364.     (void*)grDrv->_putLine_scr_and = MK_FP(seg, FP_OFF(grDrv->_putLine_scr_and));
  365.   else
  366.     grDrv->_putLine_scr_and = TGE_putLine;
  367.   if (FP_OFF(grDrv->_putLine_scr_not))        /* putLine_scr_not */
  368.     (void*)grDrv->_putLine_scr_not = MK_FP(seg, FP_OFF(grDrv->_putLine_scr_not));
  369.   else
  370.     grDrv->_putLine_scr_not = TGE_putLine;
  371.   if (FP_OFF(grDrv->_putLine_scr_or))        /* putLine_scr_or */
  372.     (void*)grDrv->_putLine_scr_or = MK_FP(seg, FP_OFF(grDrv->_putLine_scr_or));
  373.   else
  374.     grDrv->_putLine_scr_or = TGE_putLine;
  375.   if (FP_OFF(grDrv->_putLine_scr_xor))        /* putLine_scr_xor */
  376.     (void*)grDrv->_putLine_scr_xor = MK_FP(seg, FP_OFF(grDrv->_putLine_scr_xor));
  377.   else
  378.     grDrv->_putLine_scr_xor = TGE_putLine;
  379.   if (FP_OFF(grDrv->_putLine_mem_copy))        /* putLine_mem_copy */
  380.     (void*)grDrv->_putLine_mem_copy = MK_FP(seg, FP_OFF(grDrv->_putLine_mem_copy));
  381.   else
  382.     grDrv->_putLine_mem_copy = TGE_putLine;
  383.   if (FP_OFF(grDrv->_putLine_mem_and))        /* putLine_mem_and */
  384.     (void*)grDrv->_putLine_mem_and = MK_FP(seg, FP_OFF(grDrv->_putLine_mem_and));
  385.   else
  386.     grDrv->_putLine_mem_and = TGE_putLine;
  387.   if (FP_OFF(grDrv->_putLine_mem_not))        /* putLine_mem_not */
  388.     (void*)grDrv->_putLine_mem_not = MK_FP(seg, FP_OFF(grDrv->_putLine_mem_not));
  389.   else
  390.     grDrv->_putLine_mem_not = TGE_putLine;
  391.   if (FP_OFF(grDrv->_putLine_mem_or))        /* putLine_mem_or */
  392.     (void*)grDrv->_putLine_mem_or = MK_FP(seg, FP_OFF(grDrv->_putLine_mem_or));
  393.   else
  394.     grDrv->_putLine_mem_or = TGE_putLine;
  395.   if (FP_OFF(grDrv->_putLine_mem_xor))        /* putLine_mem_xor */
  396.     (void*)grDrv->_putLine_mem_xor = MK_FP(seg, FP_OFF(grDrv->_putLine_mem_xor));
  397.   else
  398.     grDrv->_putLine_mem_xor = TGE_putLine;
  399.  
  400.   if (FP_OFF(grDrv->_putLineInv_scr_copy))    /* putLineInv_scr_copy */
  401.     (void*)grDrv->_putLineInv_scr_copy = MK_FP(seg, FP_OFF(grDrv->_putLineInv_scr_copy));
  402.   else
  403.     grDrv->_putLineInv_scr_copy = TGE_putLineInv;
  404.   if (FP_OFF(grDrv->_putLineInv_scr_and))    /* putLineInv_scr_and */
  405.     (void*)grDrv->_putLineInv_scr_and = MK_FP(seg, FP_OFF(grDrv->_putLineInv_scr_and));
  406.   else
  407.     grDrv->_putLineInv_scr_and = TGE_putLineInv;
  408.   if (FP_OFF(grDrv->_putLineInv_scr_not))    /* putLineInv_scr_not */
  409.     (void*)grDrv->_putLineInv_scr_not = MK_FP(seg, FP_OFF(grDrv->_putLineInv_scr_not));
  410.   else
  411.     grDrv->_putLineInv_scr_not = TGE_putLineInv;
  412.   if (FP_OFF(grDrv->_putLineInv_scr_or))    /* putLineInv_scr_or */
  413.     (void*)grDrv->_putLineInv_scr_or = MK_FP(seg, FP_OFF(grDrv->_putLineInv_scr_or));
  414.   else
  415.     grDrv->_putLineInv_scr_or = TGE_putLineInv;
  416.   if (FP_OFF(grDrv->_putLineInv_scr_xor))    /* putLineInv_scr_xor */
  417.     (void*)grDrv->_putLineInv_scr_xor = MK_FP(seg, FP_OFF(grDrv->_putLineInv_scr_xor));
  418.   else
  419.     grDrv->_putLineInv_scr_xor = TGE_putLineInv;
  420.   if (FP_OFF(grDrv->_putLineInv_mem_copy))    /* putLineInv_mem_copy */
  421.     (void*)grDrv->_putLineInv_mem_copy = MK_FP(seg, FP_OFF(grDrv->_putLineInv_mem_copy));
  422.   else
  423.     grDrv->_putLineInv_mem_copy = TGE_putLineInv;
  424.   if (FP_OFF(grDrv->_putLineInv_mem_and))    /* putLineInv_mem_and */
  425.     (void*)grDrv->_putLineInv_mem_and = MK_FP(seg, FP_OFF(grDrv->_putLineInv_mem_and));
  426.   else
  427.     grDrv->_putLineInv_mem_and = TGE_putLineInv;
  428.   if (FP_OFF(grDrv->_putLineInv_mem_not))    /* putLineInv_mem_not */
  429.     (void*)grDrv->_putLineInv_mem_not = MK_FP(seg, FP_OFF(grDrv->_putLineInv_mem_not));
  430.   else
  431.     grDrv->_putLineInv_mem_not = TGE_putLineInv;
  432.   if (FP_OFF(grDrv->_putLineInv_mem_or))    /* putLineInv_mem_or */
  433.     (void*)grDrv->_putLineInv_mem_or = MK_FP(seg, FP_OFF(grDrv->_putLineInv_mem_or));
  434.   else
  435.     grDrv->_putLineInv_mem_or = TGE_putLineInv;
  436.   if (FP_OFF(grDrv->_putLineInv_mem_xor))    /* putLineInv_mem_xor */
  437.     (void*)grDrv->_putLineInv_mem_xor = MK_FP(seg, FP_OFF(grDrv->_putLineInv_mem_xor));
  438.   else
  439.     grDrv->_putLineInv_mem_xor = TGE_putLineInv;
  440.  
  441.   if (FP_OFF(grDrv->_putPixel_scr_copy))    /* putPixel_scr_copy */
  442.     (void*)grDrv->_putPixel_scr_copy = MK_FP(seg, FP_OFF(grDrv->_putPixel_scr_copy));
  443.   else
  444.     grDrv->_putPixel_scr_copy = TGE_putPixel_scr_copy;
  445.   if (FP_OFF(grDrv->_putPixel_scr_and))        /* putPixel_scr_and */
  446.     (void*)grDrv->_putPixel_scr_and = MK_FP(seg, FP_OFF(grDrv->_putPixel_scr_and));
  447.   else
  448.     grDrv->_putPixel_scr_and = TGE_putPixel_scr_and;
  449.   if (FP_OFF(grDrv->_putPixel_scr_not))        /* putPixel_scr_not */
  450.     (void*)grDrv->_putPixel_scr_not = MK_FP(seg, FP_OFF(grDrv->_putPixel_scr_not));
  451.   else
  452.     grDrv->_putPixel_scr_not = TGE_putPixel_scr_not;
  453.   if (FP_OFF(grDrv->_putPixel_scr_or))        /* putPixel_scr_or */
  454.     (void*)grDrv->_putPixel_scr_or = MK_FP(seg, FP_OFF(grDrv->_putPixel_scr_or));
  455.   else
  456.     grDrv->_putPixel_scr_or = TGE_putPixel_scr_or;
  457.   if (FP_OFF(grDrv->_putPixel_scr_xor))        /* putPixel_scr_xor */
  458.     (void*)grDrv->_putPixel_scr_xor = MK_FP(seg, FP_OFF(grDrv->_putPixel_scr_xor));
  459.   else
  460.     grDrv->_putPixel_scr_xor = TGE_putPixel_scr_xor;
  461.   if (FP_OFF(grDrv->_putPixel_mem_copy))    /* putPixel_mem_copy */
  462.     (void*)grDrv->_putPixel_mem_copy = MK_FP(seg, FP_OFF(grDrv->_putPixel_mem_copy));
  463.   else
  464.     grDrv->_putPixel_mem_copy = TGE_putPixel_mem_copy;
  465.   if (FP_OFF(grDrv->_putPixel_mem_and))        /* putPixel_mem_and */
  466.     (void*)grDrv->_putPixel_mem_and = MK_FP(seg, FP_OFF(grDrv->_putPixel_mem_and));
  467.   else
  468.     grDrv->_putPixel_mem_and = TGE_putPixel_mem_and;
  469.   if (FP_OFF(grDrv->_putPixel_mem_not))        /* putPixel_mem_not */
  470.     (void*)grDrv->_putPixel_mem_not = MK_FP(seg, FP_OFF(grDrv->_putPixel_mem_not));
  471.   else
  472.     grDrv->_putPixel_mem_not = TGE_putPixel_mem_not;
  473.   if (FP_OFF(grDrv->_putPixel_mem_or))        /* putPixel_mem_or */
  474.     (void*)grDrv->_putPixel_mem_or = MK_FP(seg, FP_OFF(grDrv->_putPixel_mem_or));
  475.   else
  476.     grDrv->_putPixel_mem_or = TGE_putPixel_mem_or;
  477.   if (FP_OFF(grDrv->_putPixel_mem_xor))        /* putPixel_mem_xor */
  478.     (void*)grDrv->_putPixel_mem_xor = MK_FP(seg, FP_OFF(grDrv->_putPixel_mem_xor));
  479.   else
  480.     grDrv->_putPixel_mem_xor = TGE_putPixel_mem_xor;
  481.  
  482.   if (FP_OFF(grDrv->_line_scr_copy))        /* line_scr_copy */
  483.     (void*)grDrv->_line_scr_copy = MK_FP(seg, FP_OFF(grDrv->_line_scr_copy));
  484.   else
  485.     grDrv->_line_scr_copy = TGE_line;
  486.   if (FP_OFF(grDrv->_line_scr_and))        /* line_scr_and */
  487.     (void*)grDrv->_line_scr_and = MK_FP(seg, FP_OFF(grDrv->_line_scr_and));
  488.   else
  489.     grDrv->_line_scr_and = TGE_line;
  490.   if (FP_OFF(grDrv->_line_scr_not))        /* line_scr_not */
  491.     (void*)grDrv->_line_scr_not = MK_FP(seg, FP_OFF(grDrv->_line_scr_not));
  492.   else
  493.     grDrv->_line_scr_not = TGE_line;
  494.   if (FP_OFF(grDrv->_line_scr_or))        /* line_scr_or */
  495.     (void*)grDrv->_line_scr_or = MK_FP(seg, FP_OFF(grDrv->_line_scr_or));
  496.   else
  497.     grDrv->_line_scr_or = TGE_line;
  498.   if (FP_OFF(grDrv->_line_scr_xor))        /* line_scr_xor */
  499.     (void*)grDrv->_line_scr_xor = MK_FP(seg, FP_OFF(grDrv->_line_scr_xor));
  500.   else
  501.     grDrv->_line_scr_xor = TGE_line;
  502.   if (FP_OFF(grDrv->_line_mem_copy))        /* line_mem_copy */
  503.     (void*)grDrv->_line_mem_copy = MK_FP(seg, FP_OFF(grDrv->_line_mem_copy));
  504.   else
  505.     grDrv->_line_mem_copy = TGE_line;
  506.   if (FP_OFF(grDrv->_line_mem_and))        /* line_mem_and */
  507.     (void*)grDrv->_line_mem_and = MK_FP(seg, FP_OFF(grDrv->_line_mem_and));
  508.   else
  509.     grDrv->_line_mem_and = TGE_line;
  510.   if (FP_OFF(grDrv->_line_mem_not))        /* line_mem_not */
  511.     (void*)grDrv->_line_mem_not = MK_FP(seg, FP_OFF(grDrv->_line_mem_not));
  512.   else
  513.     grDrv->_line_mem_not = TGE_line;
  514.   if (FP_OFF(grDrv->_line_mem_or))        /* line_mem_or */
  515.     (void*)grDrv->_line_mem_or = MK_FP(seg, FP_OFF(grDrv->_line_mem_or));
  516.   else
  517.     grDrv->_line_mem_or = TGE_line;
  518.   if (FP_OFF(grDrv->_line_mem_xor))        /* line_mem_xor */
  519.     (void*)grDrv->_line_mem_xor = MK_FP(seg, FP_OFF(grDrv->_line_mem_xor));
  520.   else
  521.     grDrv->_line_mem_xor = TGE_line;
  522.  
  523.   if (FP_OFF(grDrv->_horizLine_scr_copy))    /* horizLine_scr_copy */
  524.     (void*)grDrv->_horizLine_scr_copy = MK_FP(seg, FP_OFF(grDrv->_horizLine_scr_copy));
  525.   else
  526.     grDrv->_horizLine_scr_copy = TGE_horizLine;
  527.   if (FP_OFF(grDrv->_horizLine_scr_and))    /* horizLine_scr_and */
  528.     (void*)grDrv->_horizLine_scr_and = MK_FP(seg, FP_OFF(grDrv->_horizLine_scr_and));
  529.   else
  530.     grDrv->_horizLine_scr_and = TGE_horizLine;
  531.   if (FP_OFF(grDrv->_horizLine_scr_not))    /* horizLine_scr_not */
  532.     (void*)grDrv->_horizLine_scr_not = MK_FP(seg, FP_OFF(grDrv->_horizLine_scr_not));
  533.   else
  534.     grDrv->_horizLine_scr_not = TGE_horizLine;
  535.   if (FP_OFF(grDrv->_horizLine_scr_or))        /* horizLine_scr_or */
  536.     (void*)grDrv->_horizLine_scr_or = MK_FP(seg, FP_OFF(grDrv->_horizLine_scr_or));
  537.   else
  538.     grDrv->_horizLine_scr_or = TGE_horizLine;
  539.   if (FP_OFF(grDrv->_horizLine_scr_xor))    /* horizLine_scr_xor */
  540.     (void*)grDrv->_horizLine_scr_xor = MK_FP(seg, FP_OFF(grDrv->_horizLine_scr_xor));
  541.   else
  542.     grDrv->_horizLine_scr_xor = TGE_horizLine;
  543.   if (FP_OFF(grDrv->_horizLine_mem_copy))    /* horizLine_mem_copy */
  544.     (void*)grDrv->_horizLine_mem_copy = MK_FP(seg, FP_OFF(grDrv->_horizLine_mem_copy));
  545.   else
  546.     grDrv->_horizLine_mem_copy = TGE_horizLine;
  547.   if (FP_OFF(grDrv->_horizLine_mem_and))    /* horizLine_mem_and */
  548.     (void*)grDrv->_horizLine_mem_and = MK_FP(seg, FP_OFF(grDrv->_horizLine_mem_and));
  549.   else
  550.     grDrv->_horizLine_mem_and = TGE_horizLine;
  551.   if (FP_OFF(grDrv->_horizLine_mem_not))    /* horizLine_mem_not */
  552.     (void*)grDrv->_horizLine_mem_not = MK_FP(seg, FP_OFF(grDrv->_horizLine_mem_not));
  553.   else
  554.     grDrv->_horizLine_mem_not = TGE_horizLine;
  555.   if (FP_OFF(grDrv->_horizLine_mem_or))        /* horizLine_mem_or */
  556.     (void*)grDrv->_horizLine_mem_or = MK_FP(seg, FP_OFF(grDrv->_horizLine_mem_or));
  557.   else
  558.     grDrv->_horizLine_mem_or = TGE_horizLine;
  559.   if (FP_OFF(grDrv->_horizLine_mem_xor))    /* horizLine_mem_xor */
  560.     (void*)grDrv->_horizLine_mem_xor = MK_FP(seg, FP_OFF(grDrv->_horizLine_mem_xor));
  561.   else
  562.     grDrv->_horizLine_mem_xor = TGE_horizLine;
  563.  
  564.   if (FP_OFF(grDrv->_vertLine_scr_copy))    /* vertLine_scr_copy */
  565.     (void*)grDrv->_vertLine_scr_copy = MK_FP(seg, FP_OFF(grDrv->_vertLine_scr_copy));
  566.   else
  567.     grDrv->_vertLine_scr_copy = TGE_vertLine;
  568.   if (FP_OFF(grDrv->_vertLine_scr_and))        /* vertLine_scr_and */
  569.     (void*)grDrv->_vertLine_scr_and = MK_FP(seg, FP_OFF(grDrv->_vertLine_scr_and));
  570.   else
  571.     grDrv->_vertLine_scr_and = TGE_vertLine;
  572.   if (FP_OFF(grDrv->_vertLine_scr_not))        /* vertLine_scr_not */
  573.     (void*)grDrv->_vertLine_scr_not = MK_FP(seg, FP_OFF(grDrv->_vertLine_scr_not));
  574.   else
  575.     grDrv->_vertLine_scr_not = TGE_vertLine;
  576.   if (FP_OFF(grDrv->_vertLine_scr_or))        /* vertLine_scr_or */
  577.     (void*)grDrv->_vertLine_scr_or = MK_FP(seg, FP_OFF(grDrv->_vertLine_scr_or));
  578.   else
  579.     grDrv->_vertLine_scr_or = TGE_vertLine;
  580.   if (FP_OFF(grDrv->_vertLine_scr_xor))        /* vertLine_scr_xor */
  581.     (void*)grDrv->_vertLine_scr_xor = MK_FP(seg, FP_OFF(grDrv->_vertLine_scr_xor));
  582.   else
  583.     grDrv->_vertLine_scr_xor = TGE_vertLine;
  584.   if (FP_OFF(grDrv->_vertLine_mem_copy))    /* vertLine_mem_copy */
  585.     (void*)grDrv->_vertLine_mem_copy = MK_FP(seg, FP_OFF(grDrv->_vertLine_mem_copy));
  586.   else
  587.     grDrv->_vertLine_mem_copy = TGE_vertLine;
  588.   if (FP_OFF(grDrv->_vertLine_mem_and))        /* vertLine_mem_and */
  589.     (void*)grDrv->_vertLine_mem_and = MK_FP(seg, FP_OFF(grDrv->_vertLine_mem_and));
  590.   else
  591.     grDrv->_vertLine_mem_and = TGE_vertLine;
  592.   if (FP_OFF(grDrv->_vertLine_mem_not))        /* vertLine_mem_not */
  593.     (void*)grDrv->_vertLine_mem_not = MK_FP(seg, FP_OFF(grDrv->_vertLine_mem_not));
  594.   else
  595.     grDrv->_vertLine_mem_not = TGE_vertLine;
  596.   if (FP_OFF(grDrv->_vertLine_mem_or))        /* vertLine_mem_or */
  597.     (void*)grDrv->_vertLine_mem_or = MK_FP(seg, FP_OFF(grDrv->_vertLine_mem_or));
  598.   else
  599.     grDrv->_vertLine_mem_or = TGE_vertLine;
  600.   if (FP_OFF(grDrv->_vertLine_mem_xor))        /* vertLine_mem_xor */
  601.     (void*)grDrv->_vertLine_mem_xor = MK_FP(seg, FP_OFF(grDrv->_vertLine_mem_xor));
  602.   else
  603.     grDrv->_vertLine_mem_xor = TGE_vertLine;
  604.  
  605.   if (FP_OFF(grDrv->_drawRect_scr_copy))    /* drawRect_scr_copy */
  606.     (void*)grDrv->_drawRect_scr_copy = MK_FP(seg, FP_OFF(grDrv->_drawRect_scr_copy));
  607.   else
  608.     grDrv->_drawRect_scr_copy = TGE_drawRect;
  609.   if (FP_OFF(grDrv->_drawRect_scr_and))        /* drawRect_scr_and */
  610.     (void*)grDrv->_drawRect_scr_and = MK_FP(seg, FP_OFF(grDrv->_drawRect_scr_and));
  611.   else
  612.     grDrv->_drawRect_scr_and = TGE_drawRect;
  613.   if (FP_OFF(grDrv->_drawRect_scr_not))        /* drawRect_scr_not */
  614.     (void*)grDrv->_drawRect_scr_not = MK_FP(seg, FP_OFF(grDrv->_drawRect_scr_not));
  615.   else
  616.     grDrv->_drawRect_scr_not = TGE_drawRect;
  617.   if (FP_OFF(grDrv->_drawRect_scr_or))        /* drawRect_scr_or */
  618.     (void*)grDrv->_drawRect_scr_or = MK_FP(seg, FP_OFF(grDrv->_drawRect_scr_or));
  619.   else
  620.     grDrv->_drawRect_scr_or = TGE_drawRect;
  621.   if (FP_OFF(grDrv->_drawRect_scr_xor))        /* drawRect_scr_xor */
  622.     (void*)grDrv->_drawRect_scr_xor = MK_FP(seg, FP_OFF(grDrv->_drawRect_scr_xor));
  623.   else
  624.     grDrv->_drawRect_scr_xor = TGE_drawRect;
  625.   if (FP_OFF(grDrv->_drawRect_mem_copy))    /* drawRect_mem_copy */
  626.     (void*)grDrv->_drawRect_mem_copy = MK_FP(seg, FP_OFF(grDrv->_drawRect_mem_copy));
  627.   else
  628.     grDrv->_drawRect_mem_copy = TGE_drawRect;
  629.   if (FP_OFF(grDrv->_drawRect_mem_and))        /* drawRect_mem_and */
  630.     (void*)grDrv->_drawRect_mem_and = MK_FP(seg, FP_OFF(grDrv->_drawRect_mem_and));
  631.   else
  632.     grDrv->_drawRect_mem_and = TGE_drawRect;
  633.   if (FP_OFF(grDrv->_drawRect_mem_not))        /* drawRect_mem_not */
  634.     (void*)grDrv->_drawRect_mem_not = MK_FP(seg, FP_OFF(grDrv->_drawRect_mem_not));
  635.   else
  636.     grDrv->_drawRect_mem_not = TGE_drawRect;
  637.   if (FP_OFF(grDrv->_drawRect_mem_or))        /* drawRect_mem_or */
  638.     (void*)grDrv->_drawRect_mem_or = MK_FP(seg, FP_OFF(grDrv->_drawRect_mem_or));
  639.   else
  640.     grDrv->_drawRect_mem_or = TGE_drawRect;
  641.   if (FP_OFF(grDrv->_drawRect_mem_xor))        /* drawRect_mem_xor */
  642.     (void*)grDrv->_drawRect_mem_xor = MK_FP(seg, FP_OFF(grDrv->_drawRect_mem_xor));
  643.   else
  644.     grDrv->_drawRect_mem_xor = TGE_drawRect;
  645.  
  646.   if (FP_OFF(grDrv->_filledRect_scr_copy))    /* filledRect_scr_copy */
  647.     (void*)grDrv->_filledRect_scr_copy = MK_FP(seg, FP_OFF(grDrv->_filledRect_scr_copy));
  648.   else
  649.     grDrv->_filledRect_scr_copy = TGE_filledRect;
  650.   if (FP_OFF(grDrv->_filledRect_scr_and))    /* filledRect_scr_and */
  651.     (void*)grDrv->_filledRect_scr_and = MK_FP(seg, FP_OFF(grDrv->_filledRect_scr_and));
  652.   else
  653.     grDrv->_filledRect_scr_and = TGE_filledRect;
  654.   if (FP_OFF(grDrv->_filledRect_scr_not))    /* filledRect_scr_not */
  655.     (void*)grDrv->_filledRect_scr_not = MK_FP(seg, FP_OFF(grDrv->_filledRect_scr_not));
  656.   else
  657.     grDrv->_filledRect_scr_not = TGE_filledRect;
  658.   if (FP_OFF(grDrv->_filledRect_scr_or))    /* filledRect_scr_or */
  659.     (void*)grDrv->_filledRect_scr_or = MK_FP(seg, FP_OFF(grDrv->_filledRect_scr_or));
  660.   else
  661.     grDrv->_filledRect_scr_or = TGE_filledRect;
  662.   if (FP_OFF(grDrv->_filledRect_scr_xor))    /* filledRect_scr_xor */
  663.     (void*)grDrv->_filledRect_scr_xor = MK_FP(seg, FP_OFF(grDrv->_filledRect_scr_xor));
  664.   else
  665.     grDrv->_filledRect_scr_xor = TGE_filledRect;
  666.   if (FP_OFF(grDrv->_filledRect_mem_copy))    /* filledRect_mem_copy */
  667.     (void*)grDrv->_filledRect_mem_copy = MK_FP(seg, FP_OFF(grDrv->_filledRect_mem_copy));
  668.   else
  669.     grDrv->_filledRect_mem_copy = TGE_filledRect;
  670.   if (FP_OFF(grDrv->_filledRect_mem_and))    /* filledRect_mem_and */
  671.     (void*)grDrv->_filledRect_mem_and = MK_FP(seg, FP_OFF(grDrv->_filledRect_mem_and));
  672.   else
  673.     grDrv->_filledRect_mem_and = TGE_filledRect;
  674.   if (FP_OFF(grDrv->_filledRect_mem_not))    /* filledRect_mem_not */
  675.     (void*)grDrv->_filledRect_mem_not = MK_FP(seg, FP_OFF(grDrv->_filledRect_mem_not));
  676.   else
  677.     grDrv->_filledRect_mem_not = TGE_filledRect;
  678.   if (FP_OFF(grDrv->_filledRect_mem_or))    /* filledRect_mem_or */
  679.     (void*)grDrv->_filledRect_mem_or = MK_FP(seg, FP_OFF(grDrv->_filledRect_mem_or));
  680.   else
  681.     grDrv->_filledRect_mem_or = TGE_filledRect;
  682.   if (FP_OFF(grDrv->_filledRect_mem_xor))    /* filledRect_mem_xor */
  683.     (void*)grDrv->_filledRect_mem_xor = MK_FP(seg, FP_OFF(grDrv->_filledRect_mem_xor));
  684.   else
  685.     grDrv->_filledRect_mem_xor = TGE_filledRect;
  686.  
  687.   if (FP_OFF(grDrv->_clearGraphics_scr_copy))    /* clearGraphics_scr_copy */
  688.     (void*)grDrv->_clearGraphics_scr_copy = MK_FP(seg, FP_OFF(grDrv->_clearGraphics_scr_copy));
  689.   else
  690.     grDrv->_clearGraphics_scr_copy = TGE_clearGraphics;
  691.   if (FP_OFF(grDrv->_clearGraphics_scr_and))    /* clearGraphics_scr_and */
  692.     (void*)grDrv->_clearGraphics_scr_and = MK_FP(seg, FP_OFF(grDrv->_clearGraphics_scr_and));
  693.   else
  694.     grDrv->_clearGraphics_scr_and = TGE_clearGraphics;
  695.   if (FP_OFF(grDrv->_clearGraphics_scr_not))    /* clearGraphics_scr_not */
  696.     (void*)grDrv->_clearGraphics_scr_not = MK_FP(seg, FP_OFF(grDrv->_clearGraphics_scr_not));
  697.   else
  698.     grDrv->_clearGraphics_scr_not = TGE_clearGraphics;
  699.   if (FP_OFF(grDrv->_clearGraphics_scr_or))    /* clearGraphics_scr_or */
  700.     (void*)grDrv->_clearGraphics_scr_or = MK_FP(seg, FP_OFF(grDrv->_clearGraphics_scr_or));
  701.   else
  702.     grDrv->_clearGraphics_scr_or = TGE_clearGraphics;
  703.   if (FP_OFF(grDrv->_clearGraphics_scr_xor))    /* clearGraphics_scr_xor */
  704.     (void*)grDrv->_clearGraphics_scr_xor = MK_FP(seg, FP_OFF(grDrv->_clearGraphics_scr_xor));
  705.   else
  706.     grDrv->_clearGraphics_scr_xor = TGE_clearGraphics;
  707.   if (FP_OFF(grDrv->_clearGraphics_mem_copy))    /* clearGraphics_mem_copy */
  708.     (void*)grDrv->_clearGraphics_mem_copy = MK_FP(seg, FP_OFF(grDrv->_clearGraphics_mem_copy));
  709.   else
  710.     grDrv->_clearGraphics_mem_copy = TGE_clearGraphics;
  711.   if (FP_OFF(grDrv->_clearGraphics_mem_and))    /* clearGraphics_mem_and */
  712.     (void*)grDrv->_clearGraphics_mem_and = MK_FP(seg, FP_OFF(grDrv->_clearGraphics_mem_and));
  713.   else
  714.     grDrv->_clearGraphics_mem_and = TGE_clearGraphics;
  715.   if (FP_OFF(grDrv->_clearGraphics_mem_not))    /* clearGraphics_mem_not */
  716.     (void*)grDrv->_clearGraphics_mem_not = MK_FP(seg, FP_OFF(grDrv->_clearGraphics_mem_not));
  717.   else
  718.     grDrv->_clearGraphics_mem_not = TGE_clearGraphics;
  719.   if (FP_OFF(grDrv->_clearGraphics_mem_or))    /* clearGraphics_mem_or */
  720.     (void*)grDrv->_clearGraphics_mem_or = MK_FP(seg, FP_OFF(grDrv->_clearGraphics_mem_or));
  721.   else
  722.     grDrv->_clearGraphics_mem_or = TGE_clearGraphics;
  723.   if (FP_OFF(grDrv->_clearGraphics_mem_xor))    /* clearGraphics_mem_xor */
  724.     (void*)grDrv->_clearGraphics_mem_xor = MK_FP(seg, FP_OFF(grDrv->_clearGraphics_mem_xor));
  725.   else
  726.     grDrv->_clearGraphics_mem_xor = TGE_clearGraphics;
  727.  
  728.   if (FP_OFF(grDrv->_ellipse_scr_copy))        /* ellipse_scr_copy */
  729.     (void*)grDrv->_ellipse_scr_copy = MK_FP(seg, FP_OFF(grDrv->_ellipse_scr_copy));
  730.   else
  731.     grDrv->_ellipse_scr_copy = TGE_ellipse;
  732.   if (FP_OFF(grDrv->_ellipse_scr_and))        /* ellipse_scr_and */
  733.     (void*)grDrv->_ellipse_scr_and = MK_FP(seg, FP_OFF(grDrv->_ellipse_scr_and));
  734.   else
  735.     grDrv->_ellipse_scr_and = TGE_ellipse;
  736.   if (FP_OFF(grDrv->_ellipse_scr_not))        /* ellipse_scr_not */
  737.     (void*)grDrv->_ellipse_scr_not = MK_FP(seg, FP_OFF(grDrv->_ellipse_scr_not));
  738.   else
  739.     grDrv->_ellipse_scr_not = TGE_ellipse;
  740.   if (FP_OFF(grDrv->_ellipse_scr_or))        /* ellipse_scr_or */
  741.     (void*)grDrv->_ellipse_scr_or = MK_FP(seg, FP_OFF(grDrv->_ellipse_scr_or));
  742.   else
  743.     grDrv->_ellipse_scr_or = TGE_ellipse;
  744.   if (FP_OFF(grDrv->_ellipse_scr_xor))        /* ellipse_scr_xor */
  745.     (void*)grDrv->_ellipse_scr_xor = MK_FP(seg, FP_OFF(grDrv->_ellipse_scr_xor));
  746.   else
  747.     grDrv->_ellipse_scr_xor = TGE_ellipse;
  748.   if (FP_OFF(grDrv->_ellipse_mem_copy))        /* ellipse_mem_copy */
  749.     (void*)grDrv->_ellipse_mem_copy = MK_FP(seg, FP_OFF(grDrv->_ellipse_mem_copy));
  750.   else
  751.     grDrv->_ellipse_mem_copy = TGE_ellipse;
  752.   if (FP_OFF(grDrv->_ellipse_mem_and))        /* ellipse_mem_and */
  753.     (void*)grDrv->_ellipse_mem_and = MK_FP(seg, FP_OFF(grDrv->_ellipse_mem_and));
  754.   else
  755.     grDrv->_ellipse_mem_and = TGE_ellipse;
  756.   if (FP_OFF(grDrv->_ellipse_mem_not))        /* ellipse_mem_not */
  757.     (void*)grDrv->_ellipse_mem_not = MK_FP(seg, FP_OFF(grDrv->_ellipse_mem_not));
  758.   else
  759.     grDrv->_ellipse_mem_not = TGE_ellipse;
  760.   if (FP_OFF(grDrv->_ellipse_mem_or))        /* ellipse_mem_or */
  761.     (void*)grDrv->_ellipse_mem_or = MK_FP(seg, FP_OFF(grDrv->_ellipse_mem_or));
  762.   else
  763.     grDrv->_ellipse_mem_or = TGE_ellipse;
  764.   if (FP_OFF(grDrv->_ellipse_mem_xor))        /* ellipse_mem_xor */
  765.     (void*)grDrv->_ellipse_mem_xor = MK_FP(seg, FP_OFF(grDrv->_ellipse_mem_xor));
  766.   else
  767.     grDrv->_ellipse_mem_xor = TGE_ellipse;
  768.  
  769.   if (FP_OFF(grDrv->_filledEllipse_scr_copy))    /* filledEllipse_scr_copy */
  770.     (void*)grDrv->_filledEllipse_scr_copy = MK_FP(seg, FP_OFF(grDrv->_filledEllipse_scr_copy));
  771.   else
  772.     grDrv->_filledEllipse_scr_copy = TGE_filledEllipse;
  773.   if (FP_OFF(grDrv->_filledEllipse_scr_and))    /* filledEllipse_scr_and */
  774.     (void*)grDrv->_filledEllipse_scr_and = MK_FP(seg, FP_OFF(grDrv->_filledEllipse_scr_and));
  775.   else
  776.     grDrv->_filledEllipse_scr_and = TGE_filledEllipse;
  777.   if (FP_OFF(grDrv->_filledEllipse_scr_not))    /* filledEllipse_scr_not */
  778.     (void*)grDrv->_filledEllipse_scr_not = MK_FP(seg, FP_OFF(grDrv->_filledEllipse_scr_not));
  779.   else
  780.     grDrv->_filledEllipse_scr_not = TGE_filledEllipse;
  781.   if (FP_OFF(grDrv->_filledEllipse_scr_or))    /* filledEllipse_scr_or */
  782.     (void*)grDrv->_filledEllipse_scr_or = MK_FP(seg, FP_OFF(grDrv->_filledEllipse_scr_or));
  783.   else
  784.     grDrv->_filledEllipse_scr_or = TGE_filledEllipse;
  785.   if (FP_OFF(grDrv->_filledEllipse_scr_xor))    /* filledEllipse_scr_xor */
  786.     (void*)grDrv->_filledEllipse_scr_xor = MK_FP(seg, FP_OFF(grDrv->_filledEllipse_scr_xor));
  787.   else
  788.     grDrv->_filledEllipse_scr_xor = TGE_filledEllipse;
  789.   if (FP_OFF(grDrv->_filledEllipse_mem_copy))    /* filledEllipse_mem_copy */
  790.     (void*)grDrv->_filledEllipse_mem_copy = MK_FP(seg, FP_OFF(grDrv->_filledEllipse_mem_copy));
  791.   else
  792.     grDrv->_filledEllipse_mem_copy = TGE_filledEllipse;
  793.   if (FP_OFF(grDrv->_filledEllipse_mem_and))    /* filledEllipse_mem_and */
  794.     (void*)grDrv->_filledEllipse_mem_and = MK_FP(seg, FP_OFF(grDrv->_filledEllipse_mem_and));
  795.   else
  796.     grDrv->_filledEllipse_mem_and = TGE_filledEllipse;
  797.   if (FP_OFF(grDrv->_filledEllipse_mem_not))    /* filledEllipse_mem_not */
  798.     (void*)grDrv->_filledEllipse_mem_not = MK_FP(seg, FP_OFF(grDrv->_filledEllipse_mem_not));
  799.   else
  800.     grDrv->_filledEllipse_mem_not = TGE_filledEllipse;
  801.   if (FP_OFF(grDrv->_filledEllipse_mem_or))    /* filledEllipse_mem_or */
  802.     (void*)grDrv->_filledEllipse_mem_or = MK_FP(seg, FP_OFF(grDrv->_filledEllipse_mem_or));
  803.   else
  804.     grDrv->_filledEllipse_mem_or = TGE_filledEllipse;
  805.   if (FP_OFF(grDrv->_filledEllipse_mem_xor))    /* filledEllipse_mem_xor */
  806.     (void*)grDrv->_filledEllipse_mem_xor = MK_FP(seg, FP_OFF(grDrv->_filledEllipse_mem_xor));
  807.   else
  808.     grDrv->_filledEllipse_mem_xor = TGE_filledEllipse;
  809.  
  810.   if (FP_OFF(grDrv->_circle_scr_copy))        /* circle_scr_copy */
  811.     (void*)grDrv->_circle_scr_copy = MK_FP(seg, FP_OFF(grDrv->_circle_scr_copy));
  812.   else
  813.     grDrv->_circle_scr_copy = TGE_circle;
  814.   if (FP_OFF(grDrv->_circle_scr_and))        /* circle_scr_and */
  815.     (void*)grDrv->_circle_scr_and = MK_FP(seg, FP_OFF(grDrv->_circle_scr_and));
  816.   else
  817.     grDrv->_circle_scr_and = TGE_circle;
  818.   if (FP_OFF(grDrv->_circle_scr_not))        /* circle_scr_not */
  819.     (void*)grDrv->_circle_scr_not = MK_FP(seg, FP_OFF(grDrv->_circle_scr_not));
  820.   else
  821.     grDrv->_circle_scr_not = TGE_circle;
  822.   if (FP_OFF(grDrv->_circle_scr_or))        /* circle_scr_or */
  823.     (void*)grDrv->_circle_scr_or = MK_FP(seg, FP_OFF(grDrv->_circle_scr_or));
  824.   else
  825.     grDrv->_circle_scr_or = TGE_circle;
  826.   if (FP_OFF(grDrv->_circle_scr_xor))        /* circle_scr_xor */
  827.     (void*)grDrv->_circle_scr_xor = MK_FP(seg, FP_OFF(grDrv->_circle_scr_xor));
  828.   else
  829.     grDrv->_circle_scr_xor = TGE_circle;
  830.   if (FP_OFF(grDrv->_circle_mem_copy))        /* circle_mem_copy */
  831.     (void*)grDrv->_circle_mem_copy = MK_FP(seg, FP_OFF(grDrv->_circle_mem_copy));
  832.   else
  833.     grDrv->_circle_mem_copy = TGE_circle;
  834.   if (FP_OFF(grDrv->_circle_mem_and))        /* circle_mem_and */
  835.     (void*)grDrv->_circle_mem_and = MK_FP(seg, FP_OFF(grDrv->_circle_mem_and));
  836.   else
  837.     grDrv->_circle_mem_and = TGE_circle;
  838.   if (FP_OFF(grDrv->_circle_mem_not))        /* circle_mem_not */
  839.     (void*)grDrv->_circle_mem_not = MK_FP(seg, FP_OFF(grDrv->_circle_mem_not));
  840.   else
  841.     grDrv->_circle_mem_not = TGE_circle;
  842.   if (FP_OFF(grDrv->_circle_mem_or))        /* circle_mem_or */
  843.     (void*)grDrv->_circle_mem_or = MK_FP(seg, FP_OFF(grDrv->_circle_mem_or));
  844.   else
  845.     grDrv->_circle_mem_or = TGE_circle;
  846.   if (FP_OFF(grDrv->_circle_mem_xor))        /* circle_mem_xor */
  847.     (void*)grDrv->_circle_mem_xor = MK_FP(seg, FP_OFF(grDrv->_circle_mem_xor));
  848.   else
  849.     grDrv->_circle_mem_xor = TGE_circle;
  850.  
  851.   if (FP_OFF(grDrv->_filledCircle_scr_copy))    /* filledCircle_scr_copy */
  852.     (void*)grDrv->_filledCircle_scr_copy = MK_FP(seg, FP_OFF(grDrv->_filledCircle_scr_copy));
  853.   else
  854.     grDrv->_filledCircle_scr_copy = TGE_filledCircle;
  855.   if (FP_OFF(grDrv->_filledCircle_scr_and))    /* filledCircle_scr_and */
  856.     (void*)grDrv->_filledCircle_scr_and = MK_FP(seg, FP_OFF(grDrv->_filledCircle_scr_and));
  857.   else
  858.     grDrv->_filledCircle_scr_and = TGE_filledCircle;
  859.   if (FP_OFF(grDrv->_filledCircle_scr_not))    /* filledCircle_scr_not */
  860.     (void*)grDrv->_filledCircle_scr_not = MK_FP(seg, FP_OFF(grDrv->_filledCircle_scr_not));
  861.   else
  862.     grDrv->_filledCircle_scr_not = TGE_filledCircle;
  863.   if (FP_OFF(grDrv->_filledCircle_scr_or))    /* filledCircle_scr_or */
  864.     (void*)grDrv->_filledCircle_scr_or = MK_FP(seg, FP_OFF(grDrv->_filledCircle_scr_or));
  865.   else
  866.     grDrv->_filledCircle_scr_or = TGE_filledCircle;
  867.   if (FP_OFF(grDrv->_filledCircle_scr_xor))    /* filledCircle_scr_xor */
  868.     (void*)grDrv->_filledCircle_scr_xor = MK_FP(seg, FP_OFF(grDrv->_filledCircle_scr_xor));
  869.   else
  870.     grDrv->_filledCircle_scr_xor = TGE_filledCircle;
  871.   if (FP_OFF(grDrv->_filledCircle_mem_copy))    /* filledCircle_mem_copy */
  872.     (void*)grDrv->_filledCircle_mem_copy = MK_FP(seg, FP_OFF(grDrv->_filledCircle_mem_copy));
  873.   else
  874.     grDrv->_filledCircle_mem_copy = TGE_filledCircle;
  875.   if (FP_OFF(grDrv->_filledCircle_mem_and))    /* filledCircle_mem_and */
  876.     (void*)grDrv->_filledCircle_mem_and = MK_FP(seg, FP_OFF(grDrv->_filledCircle_mem_and));
  877.   else
  878.     grDrv->_filledCircle_mem_and = TGE_filledCircle;
  879.   if (FP_OFF(grDrv->_filledCircle_mem_not))    /* filledCircle_mem_not */
  880.     (void*)grDrv->_filledCircle_mem_not = MK_FP(seg, FP_OFF(grDrv->_filledCircle_mem_not));
  881.   else
  882.     grDrv->_filledCircle_mem_not = TGE_filledCircle;
  883.   if (FP_OFF(grDrv->_filledCircle_mem_or))    /* filledCircle_mem_or */
  884.     (void*)grDrv->_filledCircle_mem_or = MK_FP(seg, FP_OFF(grDrv->_filledCircle_mem_or));
  885.   else
  886.     grDrv->_filledCircle_mem_or = TGE_filledCircle;
  887.   if (FP_OFF(grDrv->_filledCircle_mem_xor))    /* filledCircle_mem_xor */
  888.     (void*)grDrv->_filledCircle_mem_xor = MK_FP(seg, FP_OFF(grDrv->_filledCircle_mem_xor));
  889.   else
  890.     grDrv->_filledCircle_mem_xor = TGE_filledCircle;
  891.  
  892.   if (FP_OFF(grDrv->_fillRegion_scr_copy))    /* fillRegion_scr_copy */
  893.     (void*)grDrv->_fillRegion_scr_copy = MK_FP(seg, FP_OFF(grDrv->_fillRegion_scr_copy));
  894.   else
  895.     grDrv->_fillRegion_scr_copy = TGE_fillRegion;
  896.   if (FP_OFF(grDrv->_fillRegion_scr_and))    /* fillRegion_scr_and */
  897.     (void*)grDrv->_fillRegion_scr_and = MK_FP(seg, FP_OFF(grDrv->_fillRegion_scr_and));
  898.   else
  899.     grDrv->_fillRegion_scr_and = TGE_fillRegion;
  900.   if (FP_OFF(grDrv->_fillRegion_scr_not))    /* fillRegion_scr_not */
  901.     (void*)grDrv->_fillRegion_scr_not = MK_FP(seg, FP_OFF(grDrv->_fillRegion_scr_not));
  902.   else
  903.     grDrv->_fillRegion_scr_not = TGE_fillRegion;
  904.   if (FP_OFF(grDrv->_fillRegion_scr_or))    /* fillRegion_scr_or */
  905.     (void*)grDrv->_fillRegion_scr_or = MK_FP(seg, FP_OFF(grDrv->_fillRegion_scr_or));
  906.   else
  907.     grDrv->_fillRegion_scr_or = TGE_fillRegion;
  908.   if (FP_OFF(grDrv->_fillRegion_scr_xor))    /* fillRegion_scr_xor */
  909.     (void*)grDrv->_fillRegion_scr_xor = MK_FP(seg, FP_OFF(grDrv->_fillRegion_scr_xor));
  910.   else
  911.     grDrv->_fillRegion_scr_xor = TGE_fillRegion;
  912.   if (FP_OFF(grDrv->_fillRegion_mem_copy))    /* fillRegion_mem_copy */
  913.     (void*)grDrv->_fillRegion_mem_copy = MK_FP(seg, FP_OFF(grDrv->_fillRegion_mem_copy));
  914.   else
  915.     grDrv->_fillRegion_mem_copy = TGE_fillRegion;
  916.   if (FP_OFF(grDrv->_fillRegion_mem_and))    /* fillRegion_mem_and */
  917.     (void*)grDrv->_fillRegion_mem_and = MK_FP(seg, FP_OFF(grDrv->_fillRegion_mem_and));
  918.   else
  919.     grDrv->_fillRegion_mem_and = TGE_fillRegion;
  920.   if (FP_OFF(grDrv->_fillRegion_mem_not))    /* fillRegion_mem_not */
  921.     (void*)grDrv->_fillRegion_mem_not = MK_FP(seg, FP_OFF(grDrv->_fillRegion_mem_not));
  922.   else
  923.     grDrv->_fillRegion_mem_not = TGE_fillRegion;
  924.   if (FP_OFF(grDrv->_fillRegion_mem_or))    /* fillRegion_mem_or */
  925.     (void*)grDrv->_fillRegion_mem_or = MK_FP(seg, FP_OFF(grDrv->_fillRegion_mem_or));
  926.   else
  927.     grDrv->_fillRegion_mem_or = TGE_fillRegion;
  928.   if (FP_OFF(grDrv->_fillRegion_mem_xor))    /* fillRegion_mem_xor */
  929.     (void*)grDrv->_fillRegion_mem_xor = MK_FP(seg, FP_OFF(grDrv->_fillRegion_mem_xor));
  930.   else
  931.     grDrv->_fillRegion_mem_xor = TGE_fillRegion;
  932.  
  933.   if (FP_OFF(grDrv->_fillLine_scr_copy))    /* fillLine_scr_copy */
  934.     (void*)grDrv->_fillLine_scr_copy = MK_FP(seg, FP_OFF(grDrv->_fillLine_scr_copy));
  935.   else
  936.     grDrv->_fillLine_scr_copy = TGEsys->_horizLine_scr_copy;
  937.   if (FP_OFF(grDrv->_fillLine_scr_and))        /* fillLine_scr_and */
  938.     (void*)grDrv->_fillLine_scr_and = MK_FP(seg, FP_OFF(grDrv->_fillLine_scr_and));
  939.   else
  940.     grDrv->_fillLine_scr_and = TGEsys->_horizLine_scr_and;
  941.   if (FP_OFF(grDrv->_fillLine_scr_not))        /* fillLine_scr_not */
  942.     (void*)grDrv->_fillLine_scr_not = MK_FP(seg, FP_OFF(grDrv->_fillLine_scr_not));
  943.   else
  944.     grDrv->_fillLine_scr_not = TGEsys->_horizLine_scr_not;
  945.   if (FP_OFF(grDrv->_fillLine_scr_or))        /* fillLine_scr_or */
  946.     (void*)grDrv->_fillLine_scr_or = MK_FP(seg, FP_OFF(grDrv->_fillLine_scr_or));
  947.   else
  948.     grDrv->_fillLine_scr_or = TGEsys->_horizLine_scr_or;
  949.   if (FP_OFF(grDrv->_fillLine_scr_xor))        /* fillLine_scr_xor */
  950.     (void*)grDrv->_fillLine_scr_xor = MK_FP(seg, FP_OFF(grDrv->_fillLine_scr_xor));
  951.   else
  952.     grDrv->_fillLine_scr_xor = TGEsys->_horizLine_scr_xor;
  953.   if (FP_OFF(grDrv->_fillLine_mem_copy))    /* fillLine_mem_copy */
  954.     (void*)grDrv->_fillLine_mem_copy = MK_FP(seg, FP_OFF(grDrv->_fillLine_mem_copy));
  955.   else
  956.     grDrv->_fillLine_mem_copy = TGEsys->_horizLine_mem_copy;
  957.   if (FP_OFF(grDrv->_fillLine_mem_and))        /* fillLine_mem_and */
  958.     (void*)grDrv->_fillLine_mem_and = MK_FP(seg, FP_OFF(grDrv->_fillLine_mem_and));
  959.   else
  960.     grDrv->_fillLine_mem_and = TGEsys->_horizLine_mem_and;
  961.   if (FP_OFF(grDrv->_fillLine_mem_not))        /* fillLine_mem_not */
  962.     (void*)grDrv->_fillLine_mem_not = MK_FP(seg, FP_OFF(grDrv->_fillLine_mem_not));
  963.   else
  964.     grDrv->_fillLine_mem_not = TGEsys->_horizLine_mem_not;
  965.   if (FP_OFF(grDrv->_fillLine_mem_or))        /* fillLine_mem_or */
  966.     (void*)grDrv->_fillLine_mem_or = MK_FP(seg, FP_OFF(grDrv->_fillLine_mem_or));
  967.   else
  968.     grDrv->_fillLine_mem_or = TGEsys->_horizLine_mem_or;
  969.   if (FP_OFF(grDrv->_fillLine_mem_xor))        /* fillLine_mem_xor */
  970.     (void*)grDrv->_fillLine_mem_xor = MK_FP(seg, FP_OFF(grDrv->_fillLine_mem_xor));
  971.   else
  972.     grDrv->_fillLine_mem_xor = TGEsys->_horizLine_mem_xor;
  973.  
  974.  
  975.   /* Set up currently active functions */
  976.   setInputFunctions(SCREEN);
  977.   setOutputFunctions(SCREEN, TGE_COPY_PUT);
  978.  
  979.   /* Set up the currently active viewports */
  980.   TGE_setViewports(0, 0, OUTMAXX, OUTMAXY);
  981. }
  982.  
  983.  
  984. /*****
  985. ****** Free graphics driver memory
  986. *****/
  987.  
  988. void TGE_unloadGraphDriver(void)
  989. {
  990.   if (drvAddr)
  991.   {
  992.     farfree(drvAddr);
  993.     drvAddr = NULL;
  994.   }
  995. }
  996.  
  997.  
  998. /******
  999. ******* High-level routines to be used if they aren't in a driver
  1000. ******/
  1001.  
  1002.  
  1003. /***
  1004. **** deInitGraphics
  1005. ***/
  1006. void TGE_deInitGraphics(void)
  1007. {
  1008.   _AX = 0x0003;
  1009.   geninterrupt(0x10);
  1010. }
  1011.  
  1012.  
  1013. /***
  1014. **** setPaletteReg
  1015. ***/
  1016. void TGE_setPaletteReg(unsigned palReg, unsigned char red, unsigned char
  1017.     blue, unsigned char green)
  1018. {
  1019.   unsigned char r, g, b;
  1020.  
  1021.   r = red >> 2;                /* translate 8-bit to 6-bit */
  1022.   if ((red&3) >= 2)            /* round up if necessary */
  1023.     r++;
  1024.   if (r > 63)                /* ensure in range 0..63 */
  1025.     r = 63;
  1026.  
  1027.   g = green >> 2;
  1028.   if ((green&3) >= 2)
  1029.     g++;
  1030.   if (g > 63)
  1031.     g = 63;
  1032.  
  1033.   b = blue >> 2;
  1034.   if ((blue&3) >= 2)
  1035.     b++;
  1036.   if (b > 63)
  1037.     b = 63;
  1038.  
  1039.   _AX = 0x1010;                /* set up registers */
  1040.   _BX = palReg;
  1041.   _DH = r;
  1042.   _CH = g;
  1043.   _CL = b;
  1044.   geninterrupt(0x10);            /* call the video BIOS */
  1045. }
  1046.  
  1047.  
  1048. /***
  1049. **** getPaletteReg
  1050. ***/
  1051. void TGE_getPaletteReg(unsigned palReg, unsigned char *red, unsigned char
  1052.     *blue, unsigned char *green)
  1053. {
  1054.   unsigned char r, g, b;
  1055.  
  1056.   _AX = 0x1015;                /* set up registers */
  1057.   _BX = palReg;
  1058.   geninterrupt(0x10);            /* call the video BIOS */
  1059.   r = _DH;
  1060.   g = _CH;
  1061.   b = _CL;
  1062.  
  1063.   *red = r << 2;            /* translate 6-bit to 8-bit */
  1064.   *green = g << 2;            /* and store new values */
  1065.   *blue = b << 2;
  1066. }
  1067.  
  1068.  
  1069. #ifdef __BORLANDC__
  1070.   #pragma option -h
  1071. #endif
  1072.  
  1073. /***
  1074. **** setBlockPalette
  1075. ***/
  1076. void TGE_setBlockPalette(unsigned firstReg, unsigned lastReg, void far *data)
  1077. {
  1078.   register unsigned count;
  1079.   unsigned char r, g, b;
  1080.   unsigned char huge *p;
  1081.  
  1082.   p = (unsigned char*) data;        /* initialize pointer */
  1083.  
  1084.   for (count=firstReg; count<=lastReg; count++)    /* main loop */
  1085.   {
  1086.     r = *p >> 2;            /* translate 8-bit to 6-bit */
  1087.     if ((*p&3) >= 2)            /* round up if necessary */
  1088.       r++;
  1089.     if (r > 63)                /* ensure in range 0..63 */
  1090.       r = 63;
  1091.     p++;                     /* update pointer */
  1092.  
  1093.     g = *p >> 2;
  1094.     if ((*p&3) >= 2)
  1095.       g++;
  1096.     if (g > 63)
  1097.       g = 63;
  1098.     p++;
  1099.  
  1100.     b = *p >> 2;
  1101.     if ((*p&3) >= 2)
  1102.       b++;
  1103.     if (b > 63)
  1104.       b = 63;
  1105.     p++;
  1106.  
  1107.     _AX = 0x1010;            /* set up registers */
  1108.     _BX = count;
  1109.     _DH = r;
  1110.     _CH = g;
  1111.     _CL = b;
  1112.     geninterrupt(0x10);            /* call the video BIOS */
  1113.   }
  1114. }
  1115.  
  1116.  
  1117. /***
  1118. **** getBlockPalette
  1119. ***/
  1120. void TGE_getBlockPalette(unsigned firstReg, unsigned lastReg, void far *data)
  1121. {
  1122.   register unsigned count;
  1123.   unsigned char r, g, b;
  1124.   unsigned char huge *p;
  1125.  
  1126.   p = (unsigned char*) data;        /* initialize pointer */
  1127.  
  1128.   for (count=firstReg; count<=lastReg; count++)    /* main loop */
  1129.   {
  1130.     _AX = 0x1015;            /* set up registers */
  1131.     _BX = count;
  1132.     geninterrupt(0x10);            /* call the video BIOS */
  1133.     r = _DH;
  1134.     g = _CH;
  1135.     b = _CL;
  1136.  
  1137.     *p = r << 2;            /* translate 6-bit to 8-bit */
  1138.     p++;                /* and store values */
  1139.     *p = g << 2;
  1140.     p++;
  1141.     *p = b << 2;
  1142.     p++;
  1143.   }
  1144. }
  1145.  
  1146.  
  1147. /***
  1148. **** colourCloseTo
  1149. ***/
  1150. static unsigned char palette[768];
  1151.  
  1152. unsigned TGE_colourCloseTo(unsigned char red, unsigned char green, unsigned
  1153.     char blue)
  1154. {
  1155.   register int count;
  1156.   int redDif, greenDif, blueDif, curDif, bestDif=1000, curNet, bestNet=1000;
  1157.   unsigned bestColour;
  1158.  
  1159.   TGEsys->_getBlockPalette(0, 255, palette);    /* get the palette */
  1160.  
  1161.   for (count=255; count>=0; count--)
  1162.   {
  1163.     redDif = red - palette[3*count];       /* calculate greatest difference */
  1164.     greenDif = green - palette[3*count+1];
  1165.     blueDif = blue - palette[3*count+2];
  1166.     curNet = redDif + greenDif + blueDif;
  1167.     if (redDif < 0)
  1168.       redDif = -redDif;
  1169.     if (greenDif < 0)
  1170.       greenDif = -greenDif;
  1171.     if (blueDif < 0)
  1172.       blueDif = -blueDif;
  1173.     curDif = max(max(redDif,greenDif), blueDif);
  1174.  
  1175.     if (!curDif)            /* if same colour, return */
  1176.     {
  1177.       bestColour = count;
  1178.       break;
  1179.     }
  1180.     if (curDif < bestDif)        /* if better colour, set bestColour */
  1181.     {
  1182.       if (curNet <= bestNet)
  1183.       {
  1184.         bestDif = curDif;
  1185.         bestColour = count;
  1186.       }
  1187.     }
  1188.   }
  1189.  
  1190.   return (bestColour);
  1191. }
  1192.  
  1193.  
  1194. /***
  1195. **** colourCloseToX
  1196. ***/
  1197. unsigned TGE_colourCloseToX(unsigned char red, unsigned char green, unsigned
  1198.     char blue, unsigned colourExclude)
  1199. {
  1200.   register int count;
  1201.   int redDif, greenDif, blueDif, curDif, bestDif=1000, curNet, bestNet=1000;
  1202.   unsigned bestColour;
  1203.  
  1204.   TGEsys->_getBlockPalette(0, 255, palette);    /* get the palette */
  1205.  
  1206.   for (count=255; count>=0; count--)
  1207.   {
  1208.     if (count != colourExclude)
  1209.     {
  1210.       redDif = red - palette[3*count];  /* calculate greatest difference */
  1211.       greenDif = green - palette[3*count+1];
  1212.       blueDif = blue - palette[3*count+2];
  1213.       curNet = redDif + greenDif + blueDif;
  1214.       if (redDif < 0)
  1215.     redDif = -redDif;
  1216.       if (greenDif < 0)
  1217.     greenDif = -greenDif;
  1218.       if (blueDif < 0)
  1219.     blueDif = -blueDif;
  1220.       curDif = max(max(redDif,greenDif), blueDif);
  1221.  
  1222.       if (!curDif)            /* if same colour, return */
  1223.       {
  1224.     bestColour = count;
  1225.     break;
  1226.       }
  1227.       if (curDif < bestDif)        /* if better colour, set bestColour */
  1228.       {
  1229.     if (curNet <= bestNet)
  1230.     {
  1231.       bestDif = curDif;
  1232.       bestColour = count;
  1233.     }
  1234.       }
  1235.     }
  1236.   }
  1237.  
  1238.   return (bestColour);
  1239. }
  1240.  
  1241.  
  1242. /***
  1243. **** imageSize
  1244. ***/
  1245. unsigned long TGE_imageSize(int ulx, int uly, int lrx, int lry)
  1246. {
  1247.   unsigned long size;
  1248.   int temp;
  1249.  
  1250.   if (lrx < ulx)            /* swap coordinates if necessary */
  1251.   {
  1252.     temp = ulx;
  1253.     lrx = ulx;
  1254.     lrx = temp;
  1255.   }
  1256.   if (lry < uly)
  1257.   {
  1258.     temp = uly;
  1259.     lry = uly;
  1260.     lry = temp;
  1261.   }
  1262.  
  1263.   if (ulx < VIEWPORTULX)        /* ensure coords are in bounds */
  1264.     ulx = VIEWPORTULX;
  1265.   else if (ulx > VIEWPORTLRX)
  1266.     ulx = VIEWPORTLRX;
  1267.  
  1268.   if (uly < VIEWPORTULY)
  1269.     uly = VIEWPORTULY;
  1270.   else if (uly > VIEWPORTLRY)
  1271.     uly = VIEWPORTLRY;
  1272.  
  1273.   if (lrx < VIEWPORTULX)
  1274.     lrx = VIEWPORTULX;
  1275.   else if (lrx > VIEWPORTLRX)
  1276.     lrx = VIEWPORTLRX;
  1277.  
  1278.   if (lry < VIEWPORTULY)
  1279.     lry = VIEWPORTULY;
  1280.   else if (lry > VIEWPORTLRY)
  1281.     lry = VIEWPORTLRY;
  1282.  
  1283.   size = (unsigned long)(lrx-ulx+1);
  1284.   size *= (unsigned long)(lry-uly+1);
  1285.  
  1286.   return (size+4);            /* +4 for dimension information */
  1287. }
  1288.  
  1289.  
  1290. /***
  1291. **** imageSizeDim
  1292. ***/
  1293. unsigned long TGE_imageSizeDim(unsigned wide, unsigned deep)
  1294. {
  1295.   unsigned long size;
  1296.  
  1297.   size = wide;
  1298.   size *= deep;
  1299.  
  1300.   return (size+4);            /* +4 for dimension information */
  1301. }
  1302.  
  1303.  
  1304. #ifdef __BORLANDC__
  1305.   #pragma option -h-
  1306. #endif
  1307.  
  1308. /***
  1309. **** putImage
  1310. ***/
  1311. void huge TGE_putImage(int x, int y, void far *image)
  1312. {
  1313.   register unsigned ycount;
  1314.   int wide, deep;
  1315.   register unsigned srcAdd = 0;
  1316.   unsigned char huge *p = (unsigned char *)image;
  1317.  
  1318.   wide = ((unsigned*)image)[0];        /* get image dimensions */
  1319.   deep = ((unsigned*)image)[1];
  1320.   p += 4;                /* point to start of image data */
  1321.  
  1322.   if (y < VIEWPORTULY)            /* clip y coordinate */
  1323.   {
  1324.     if (y+deep >= VIEWPORTULY)
  1325.     {
  1326.       p += wide * abs(VIEWPORTULY-y);    /* skip any offscreen rows */
  1327.       deep -= abs(VIEWPORTULY-y);    /* update image depth */
  1328.       y = VIEWPORTULY;            /* new y coordinate */
  1329.     }
  1330.     else
  1331.       return;
  1332.   }
  1333.   else if (y > VIEWPORTLRY)
  1334.     return;
  1335.   if (y+deep > VIEWPORTLRY)
  1336.     deep = VIEWPORTLRY-y + 1;
  1337.  
  1338.   if (x < VIEWPORTULX)            /* clip x coordinate */
  1339.   {
  1340.     if (x+wide >= VIEWPORTULX)
  1341.     {
  1342.       srcAdd += abs(VIEWPORTULX-x);
  1343.       p += abs(VIEWPORTULX-x);
  1344.       wide -= abs(VIEWPORTULX-x);
  1345.       x = VIEWPORTULX;
  1346.     }
  1347.     else
  1348.       return;
  1349.   }
  1350.   else if (x > VIEWPORTLRX)
  1351.     return;
  1352.   if (x+wide > VIEWPORTLRX)
  1353.   {
  1354.     srcAdd += wide-1 - (VIEWPORTLRX-x);
  1355.     wide = VIEWPORTLRX-x + 1;
  1356.   }
  1357.  
  1358.   if (wide && deep)            /* quit if image is 0x0 pixels */
  1359.   {
  1360.     srcAdd += wide;
  1361.     for (ycount=0; ycount<deep; ycount++)
  1362.     {
  1363.       TGEsys->_putLine(y+ycount, x, wide, (void*)p);
  1364.       p += srcAdd;
  1365.     }
  1366.   }
  1367. }
  1368.  
  1369.  
  1370. /***
  1371. **** putImageInv
  1372. ***/
  1373. void huge TGE_putImageInv(int x, int y, void far *image)
  1374. {
  1375.   register unsigned ycount;
  1376.   int wide, deep;
  1377.   register unsigned srcAdd = 0;
  1378.   unsigned char huge *p = (unsigned char *)image;
  1379.  
  1380.   wide = ((unsigned*)image)[0];        /* get image dimensions */
  1381.   deep = ((unsigned*)image)[1];
  1382.   p += 4;                /* point to start of image data */
  1383.  
  1384.   if (y < OUTVIEWPORTULY)        /* clip y coordinate */
  1385.   {
  1386.     if (y+deep > OUTVIEWPORTULY)
  1387.     {
  1388.       p += wide * abs(OUTVIEWPORTULY-y);/* skip any offscreen rows */
  1389.       deep -= abs(OUTVIEWPORTULY-y);    /* update image depth */
  1390.       y = OUTVIEWPORTULY;        /* new y coordinate */
  1391.     }
  1392.     else
  1393.       return;
  1394.   }
  1395.   else if (y > OUTVIEWPORTLRY)
  1396.     return;
  1397.   if (y+deep > OUTVIEWPORTLRY)
  1398.     deep = OUTVIEWPORTLRY-y + 1;
  1399.  
  1400.   if (x < OUTVIEWPORTULX)        /* clip x coordinate */
  1401.   {
  1402.     if (x+wide > OUTVIEWPORTULX)
  1403.     {
  1404.       srcAdd += abs(OUTVIEWPORTULX-x);
  1405.       p += abs(OUTVIEWPORTULX-x);
  1406.       wide -= abs(OUTVIEWPORTULX-x);
  1407.       x = OUTVIEWPORTULX;
  1408.     }
  1409.     else
  1410.       return;
  1411.   }
  1412.   else if (x > OUTVIEWPORTLRX)
  1413.     return;
  1414.   if (x+wide > OUTVIEWPORTLRX)
  1415.   {
  1416.     srcAdd += wide-1 - (OUTVIEWPORTLRX-x);
  1417.     wide = OUTVIEWPORTLRX-x + 1;
  1418.   }
  1419.  
  1420.   if (wide && deep)               /* quit if offscreen */
  1421.   {
  1422.     srcAdd += wide;
  1423.     for (ycount=0; ycount<deep; ycount++)
  1424.     {
  1425.       TGEsys->_putLineInv(y+ycount, x, wide, (void*)p);
  1426.       p += srcAdd;
  1427.     }
  1428.   }
  1429. }
  1430.  
  1431.  
  1432. /***
  1433. **** getImage
  1434. ***/
  1435. void huge TGE_getImage(int ulx, int uly, int lrx, int lry, void far *image)
  1436. {
  1437.   register int ycount, wide, deep;
  1438.   int temp;
  1439.   unsigned char huge *p = (unsigned char*)image;
  1440.  
  1441.   if (lrx < ulx)            /* swap coordinates if necessary */
  1442.   {
  1443.     temp = ulx;
  1444.     lrx = ulx;
  1445.     lrx = temp;
  1446.   }
  1447.   if (lry < uly)
  1448.   {
  1449.     temp = uly;
  1450.     lry = uly;
  1451.     lry = temp;
  1452.   }
  1453.  
  1454.   if (ulx < INVIEWPORTULX)        /* ensure coords are in bounds */
  1455.     ulx = INVIEWPORTULX;
  1456.   else if (ulx > INVIEWPORTLRX)
  1457.     ulx = INVIEWPORTLRX;
  1458.  
  1459.   if (uly < INVIEWPORTULY)
  1460.     uly = INVIEWPORTULY;
  1461.   else if (uly > INVIEWPORTLRY)
  1462.     uly = INVIEWPORTLRY;
  1463.  
  1464.   if (lrx < INVIEWPORTULX)
  1465.     lrx = INVIEWPORTULX;
  1466.   else if (lrx > INVIEWPORTLRX)
  1467.     lrx = INVIEWPORTLRX;
  1468.  
  1469.   if (lry < INVIEWPORTULY)
  1470.     lry = INVIEWPORTULY;
  1471.   else if (lry > INVIEWPORTLRY)
  1472.     lry = INVIEWPORTLRY;
  1473.  
  1474.   ((unsigned *)image)[0] = wide = lrx-ulx+1;
  1475.   ((unsigned *)image)[1] = deep = lry-uly+1;
  1476.   p += 4;
  1477.  
  1478.   if (wide>0 && deep>0)
  1479.   {
  1480.     for (ycount=uly; ycount<=lry; ycount++)
  1481.     {
  1482.       TGEsys->_getLine(ycount, ulx, wide, (void*)p);
  1483.       p += wide;
  1484.     }
  1485.   }
  1486. }
  1487.  
  1488.  
  1489. /***
  1490. **** putLine
  1491. ***/
  1492. void TGE_putLine(int lineNum, int xOff, int lineLen, void far *buf)
  1493. {
  1494.   register unsigned count, y;
  1495.  
  1496.   for (count=0,y=lineNum; count<lineLen; count++)    /* draw the line */
  1497.     TGEsys->_putPixel(xOff+count, y, *((unsigned char huge*)buf+count));
  1498. }
  1499.  
  1500.  
  1501. /***
  1502. **** putLineInv
  1503. ***/
  1504. void TGE_putLineInv(int lineNum, int xOff, int lineLen, void far *buf)
  1505. {
  1506.   register unsigned count, y;
  1507.   unsigned char huge *p = (unsigned char huge*) buf;
  1508.  
  1509.   for (count=0,y=lineNum; count<lineLen; count++)    /* draw the line */
  1510.   {
  1511.     if (*p)
  1512.       TGEsys->_putPixel(xOff+count, y, *p);
  1513.     p++;
  1514.   }
  1515. }
  1516.  
  1517.  
  1518. /***
  1519. **** getLine
  1520. ***/
  1521. void TGE_getLine(int lineNum, int xOff, int lineLen, void far *buf)
  1522. {
  1523.   register unsigned count, y;
  1524.  
  1525.   for (count=0,y=lineNum; count<lineLen; count++)          /* draw the line */
  1526.     *((unsigned char huge*)buf+count) = TGEsys->_getPixel(xOff+count, y);
  1527. }
  1528.  
  1529.  
  1530. /***
  1531. **** putPixel
  1532. ***/
  1533. void TGE_putPixel_scr_copy(int x, int y, unsigned colour)
  1534. {
  1535.   _AH = 0x0C;
  1536.   _AL = (unsigned char)colour;
  1537.   _BH = 0;
  1538.   _CX = x;
  1539.   _DX = y;
  1540.   geninterrupt(0x10);
  1541. }
  1542.  
  1543. void TGE_putPixel_scr_and(int x, int y, unsigned colour)
  1544. {
  1545.   _AH = 0x0D;                /* get the pixel */
  1546.   _BH = 0;
  1547.   _CX = x;
  1548.   _DX = y;
  1549.   geninterrupt(0x10);
  1550.  
  1551.   _AH = 0x0C;                /* set the ANDed pixel */
  1552.   _AL &= (unsigned char)colour;
  1553.   _BH = 0;
  1554.   _CX = x;
  1555.   _DX = y;
  1556.   geninterrupt(0x10);
  1557. }
  1558.  
  1559. void TGE_putPixel_scr_not(int x, int y, unsigned colour)
  1560. {
  1561.   _AH = 0x0C;                /* set the NOTed pixel */
  1562.   _AL = ~(unsigned char)colour;
  1563.   _BH = 0;
  1564.   _CX = x;
  1565.   _DX = y;
  1566.   geninterrupt(0x10);
  1567. }
  1568.  
  1569. void TGE_putPixel_scr_or(int x, int y, unsigned colour)
  1570. {
  1571.   _AH = 0x0D;                /* get the pixel */
  1572.   _BH = 0;
  1573.   _CX = x;
  1574.   _DX = y;
  1575.   geninterrupt(0x10);
  1576.  
  1577.   _AH = 0x0C;                /* set the ORed pixel */
  1578.   _AL |= (unsigned char)colour;
  1579.   _BH = 0;
  1580.   _CX = x;
  1581.   _DX = y;
  1582.   geninterrupt(0x10);
  1583. }
  1584.  
  1585. void TGE_putPixel_scr_xor(int x, int y, unsigned colour)
  1586. {
  1587.   _AH = 0x0D;                /* get the pixel */
  1588.   _BH = 0;
  1589.   _CX = x;
  1590.   _DX = y;
  1591.   geninterrupt(0x10);
  1592.  
  1593.   _AH = 0x0C;                /* set the XORed pixel */
  1594.   _AL ^= (unsigned char)colour;
  1595.   _BH = 0;
  1596.   _CX = x;
  1597.   _DX = y;
  1598.   geninterrupt(0x10);
  1599. }
  1600.  
  1601. void TGE_putPixel_mem_copy(int x, int y, unsigned colour)
  1602. {
  1603.   *(outPixelAddr(x,y)) = (unsigned char)colour;     /* write the pixel */
  1604. }
  1605.  
  1606. void TGE_putPixel_mem_and(int x, int y, unsigned colour)
  1607. {
  1608.   *(outPixelAddr(x,y)) &= (unsigned char)colour; /* write the pixel */
  1609. }
  1610.  
  1611. void TGE_putPixel_mem_not(int x, int y, unsigned colour)
  1612. {
  1613.   *(outPixelAddr(x,y)) = ~(unsigned char)colour; /* write the pixel */
  1614. }
  1615.  
  1616. void TGE_putPixel_mem_or(int x, int y, unsigned colour)
  1617. {
  1618.   *(outPixelAddr(x,y)) |= (unsigned char)colour; /* write the pixel */
  1619. }
  1620.  
  1621. void TGE_putPixel_mem_xor(int x, int y, unsigned colour)
  1622. {
  1623.   *(outPixelAddr(x,y)) ^= (unsigned char)colour; /* write the pixel */
  1624. }
  1625.  
  1626.  
  1627. /***
  1628. **** getPixel
  1629. ***/
  1630. unsigned TGE_getPixel_scr(int x, int y)
  1631. {
  1632.   _AH = 0x0D;
  1633.   _BH = 0;
  1634.   _CX = x;
  1635.   _DX = y;
  1636.   geninterrupt(0x10);
  1637.  
  1638.   _AH = 0;
  1639.   return (_AX);
  1640. }
  1641.  
  1642. unsigned TGE_getPixel_mem(int x, int y)
  1643. {
  1644.   return ((unsigned) *(inPixelAddr(x,y)));
  1645. }
  1646.  
  1647.  
  1648. /***
  1649. **** line
  1650. ***/
  1651. void TGE_line(int x1, int y1, int x2, int y2, unsigned colour)
  1652. {
  1653.   register int t, distance;
  1654.   int xerr=0, yerr=0, deltax, deltay;
  1655.   int incx, incy;
  1656.  
  1657.   deltax = x2 - x1;            /* compute both distances */
  1658.   deltay = y2 - y1;
  1659.  
  1660.   if (deltax > 0)            /* compute increments */
  1661.     incx = 1;
  1662.   else if (deltax == 0)
  1663.     incx = 0;
  1664.   else
  1665.     incx = -1;
  1666.  
  1667.   if (deltay > 0)
  1668.     incy = 1;
  1669.   else if (deltay == 0)
  1670.     incy = 0;
  1671.   else
  1672.     incy = -1;
  1673.  
  1674.   deltax = abs(deltax);            /* determine greater distance */
  1675.   deltay = abs(deltay);
  1676.   if (deltax > deltay)
  1677.     distance = deltax;
  1678.   else
  1679.     distance = deltay;
  1680.  
  1681.   for (t=0; t<=distance+1; t++)        /* draw the line */
  1682.   {
  1683.     TGEsys->_putPixel(x1, y1, colour);
  1684.     xerr += deltax;
  1685.     yerr += deltay;
  1686.     if (xerr > distance)
  1687.     {
  1688.       xerr -= distance;
  1689.       x1 += incx;
  1690.     }
  1691.     if (yerr > distance)
  1692.     {
  1693.       yerr -= distance;
  1694.       y1 += incy;
  1695.     }
  1696.   }
  1697. }
  1698.  
  1699.  
  1700. /***
  1701. **** horizLine
  1702. ***/
  1703. void TGE_horizLine(int y, int x1, int x2, unsigned colour)
  1704. {
  1705.   register unsigned count, max;
  1706.  
  1707.   for (count=x1,max=x2; count<=max; count++)    /* draw the line */
  1708.     TGEsys->_putPixel(count, y, colour);
  1709. }
  1710.  
  1711.  
  1712. /***
  1713. **** vertLine
  1714. ***/
  1715. void TGE_vertLine(int x, int y1, int y2, unsigned colour)
  1716. {
  1717.   register unsigned count, max;
  1718.  
  1719.   for (count=y1,max=y2; count<=max; count++)    /* draw the line */
  1720.     TGEsys->_putPixel(x, count, colour);
  1721. }
  1722.  
  1723.  
  1724. /***
  1725. **** drawRect
  1726. ***/
  1727. void TGE_drawRect(int ulx, int uly, int lrx, int lry, unsigned colour)
  1728. {
  1729.   register int ulxTemp, lrxTemp, temp;
  1730.  
  1731.   if (ulx > lrx)            /* swap coords if necessary */
  1732.   {
  1733.     temp = ulx;
  1734.     ulx = lrx;
  1735.     lrx = temp;
  1736.   }
  1737.   if (uly > lry)
  1738.   {
  1739.     temp = uly;
  1740.     uly = lry;
  1741.     lry = temp;
  1742.   }
  1743.  
  1744.   if (ulx<=VIEWPORTLRX && uly<=VIEWPORTLRY && lrx>=VIEWPORTULX &&
  1745.     lry>=VIEWPORTULY)
  1746.   {
  1747.     ulxTemp = ulx+1>=VIEWPORTULX ? ulx+1 : VIEWPORTULX;
  1748.     lrxTemp = lrx-1<=VIEWPORTLRX ? lrx-1 : VIEWPORTLRX;
  1749.  
  1750.     /* Draw horizontal lines if necessary */
  1751.     if (lrxTemp-ulxTemp > 1)
  1752.     {
  1753.       if (uly >= VIEWPORTULY)
  1754.     TGEsys->_horizLine(uly, ulxTemp, lrxTemp, colour);    /* top */
  1755.       if (lry <= VIEWPORTLRY)
  1756.     TGEsys->_horizLine(lry, ulxTemp, lrxTemp, colour);    /* bottom */
  1757.     }
  1758.  
  1759.     /* Clip y coordinates */
  1760.     if (uly < VIEWPORTULY)
  1761.       uly = VIEWPORTULY;
  1762.     if (lry > VIEWPORTLRY)
  1763.       lry = VIEWPORTLRY;
  1764.  
  1765.     /* Draw vertical lines if necessary */
  1766.     if (ulx >= VIEWPORTULX)
  1767.       TGEsys->_vertLine(ulx, uly, lry, colour);            /* left */
  1768.     if (lrx <= VIEWPORTLRX)
  1769.       TGEsys->_vertLine(lrx, uly, lry, colour);            /* right */
  1770.   }
  1771. }
  1772.  
  1773.  
  1774. /***
  1775. **** filledRect
  1776. ***/
  1777. void TGE_filledRect(int ulx, int uly, int lrx, int lry, unsigned
  1778.     colour)
  1779. {
  1780.   register unsigned count, max;
  1781.   int temp;
  1782.  
  1783.   if (ulx > lrx)            /* swap coords if necessary */
  1784.   {
  1785.     temp = ulx;
  1786.     ulx = lrx;
  1787.     lrx = temp;
  1788.   }
  1789.   if (uly > lry)
  1790.   {
  1791.     temp = uly;
  1792.     uly = lry;
  1793.     lry = temp;
  1794.   }
  1795.  
  1796.   max = lry;
  1797.   for (count=uly; count<=max; count++)
  1798.     TGEsys->_fillLine(count, ulx, lrx, colour);
  1799. }
  1800.  
  1801.  
  1802. /***
  1803. **** clearGraphics
  1804. ***/
  1805. void TGE_clearGraphics(unsigned colour)
  1806. {
  1807.   TGEsys->_filledRect(0, 0, MAXX, MAXY, colour);
  1808. }
  1809.  
  1810.  
  1811. /***
  1812. **** ellipse
  1813. ***/
  1814. void TGE_ellipse(int xc, int yc, int wide, int deep, unsigned colour)
  1815. {
  1816.   int x, y;
  1817.   long a, b;
  1818.   long Asquared, TwoAsquared;
  1819.   long Bsquared, TwoBsquared;
  1820.   long d, dx, dy;
  1821.  
  1822.   wide /= 2;
  1823.   deep /= 2;
  1824.  
  1825.   x = 0;                /* initialize variables */
  1826.   y = deep;
  1827.   a = wide;
  1828.   b = deep;
  1829.   Asquared = a * a;
  1830.   TwoAsquared = 2 * Asquared;
  1831.   Bsquared = b * b;
  1832.   TwoBsquared = 2 * Bsquared;
  1833.  
  1834.   d = Bsquared - Asquared*b + Asquared/4L;
  1835.   dx = 0;
  1836.   dy = TwoAsquared * b;
  1837.  
  1838.   while (dx < dy)
  1839.   {
  1840.     set4Pixels(x, y, xc, yc, colour);
  1841.  
  1842.     if (d > 0L)
  1843.     {
  1844.       y--;
  1845.       dy -= TwoAsquared;
  1846.       d -= dy;
  1847.     }
  1848.  
  1849.     x++;
  1850.     dx += TwoBsquared;
  1851.     d += Bsquared + dx;
  1852.   }
  1853.  
  1854.   d += (3L*(Asquared-Bsquared)/2L - (dx+dy)) / 2L;
  1855.  
  1856.   while (y >= 0)
  1857.   {
  1858.     set4Pixels(x, y, xc, yc, colour);
  1859.  
  1860.     if (d < 0L)
  1861.     {
  1862.       x++;
  1863.       dx += TwoBsquared;
  1864.       d += dx;
  1865.     }
  1866.  
  1867.     y--;
  1868.     dy -= TwoAsquared;
  1869.     d += Asquared - dy;
  1870.   }
  1871. }
  1872.  
  1873. void near set4Pixels(int x, int y, int xc, int yc, unsigned colour)
  1874. {
  1875.   register int xCoord, yCoord;
  1876.  
  1877.   xCoord = xc + x;
  1878.   yCoord = yc + y;
  1879.   if (TGE_clipPoint(xCoord, yCoord))
  1880.     TGEsys->_putPixel(xCoord, yCoord, colour);
  1881.  
  1882.   xCoord = xc - x;
  1883.   if (TGE_clipPoint(xCoord, yCoord))
  1884.     TGEsys->_putPixel(xCoord, yCoord, colour);
  1885.  
  1886.   xCoord = xc + x;
  1887.   yCoord = yc - y;
  1888.   if (TGE_clipPoint(xCoord, yCoord))
  1889.     TGEsys->_putPixel(xCoord, yCoord, colour);
  1890.  
  1891.   xCoord = xc - x;
  1892.   if (TGE_clipPoint(xCoord, yCoord))
  1893.     TGEsys->_putPixel(xCoord, yCoord, colour);
  1894. }
  1895.  
  1896.  
  1897. /***
  1898. **** filledEllipse
  1899. ***/
  1900. void TGE_filledEllipse(int xc, int yc, int wide, int deep, unsigned colour)
  1901. {
  1902.   int x, y;
  1903.   long a, b;
  1904.   long Asquared, TwoAsquared;
  1905.   long Bsquared, TwoBsquared;
  1906.   long d, dx, dy;
  1907.  
  1908.   wide /= 2;
  1909.   deep /= 2;
  1910.  
  1911.   x = 0;                /* initialize variables */
  1912.   y = deep;
  1913.   a = wide;
  1914.   b = deep;
  1915.   Asquared = a * a;
  1916.   TwoAsquared = 2 * Asquared;
  1917.   Bsquared = b * b;
  1918.   TwoBsquared = 2 * Bsquared;
  1919.  
  1920.   d = Bsquared - Asquared*b + Asquared/4L;
  1921.   dx = 0;
  1922.   dy = TwoAsquared * b;
  1923.  
  1924.   while (dx < dy)
  1925.   {
  1926.     fill4Pixels(x, y, xc, yc, colour);
  1927.  
  1928.     if (d > 0L)
  1929.     {
  1930.       y--;
  1931.       dy -= TwoAsquared;
  1932.       d -= dy;
  1933.     }
  1934.  
  1935.     x++;
  1936.     dx += TwoBsquared;
  1937.     d += Bsquared + dx;
  1938.   }
  1939.  
  1940.   d += (3L*(Asquared-Bsquared)/2L - (dx+dy)) / 2L;
  1941.  
  1942.   while (y >= 0)
  1943.   {
  1944.     fill4Pixels(x, y, xc, yc, colour);
  1945.  
  1946.     if (d < 0L)
  1947.     {
  1948.       x++;
  1949.       dx += TwoBsquared;
  1950.       d += dx;
  1951.     }
  1952.  
  1953.     y--;
  1954.     dy -= TwoAsquared;
  1955.     d += Asquared - dy;
  1956.   }
  1957. }
  1958.  
  1959. void near fill4Pixels(int x, int y, int xc, int yc, unsigned colour)
  1960. {
  1961.   register int xCoord1, xCoord2, yCoord;
  1962.   int temp;
  1963.  
  1964.   xCoord1 = xc - x;
  1965.   xCoord2 = xc + x;
  1966.  
  1967.   if (xCoord1>VIEWPORTLRX || xCoord2<VIEWPORTULX)
  1968.     return;
  1969.  
  1970.   if (xCoord1 > xCoord2)        /* ensure xCoord1 <= xCoord2 */
  1971.   {
  1972.     temp = xCoord1;
  1973.     xCoord1 = xCoord2;
  1974.     xCoord2 = temp;
  1975.   }
  1976.  
  1977.   yCoord = yc - y;
  1978.   if (yCoord>=VIEWPORTULY && yCoord<=VIEWPORTLRY)
  1979.   {
  1980.     if (xCoord1 < VIEWPORTULX)        /* clip xCoord1 horizontally */
  1981.       xCoord1 = VIEWPORTULX;
  1982.     else if (xCoord1 > VIEWPORTLRX)
  1983.       xCoord1 = VIEWPORTLRX;
  1984.     if (xCoord2 < VIEWPORTULX)        /* clip xCoord2 horizontally */
  1985.       xCoord2 = VIEWPORTULX;
  1986.     else if (xCoord2 > VIEWPORTLRX)
  1987.       xCoord2 = VIEWPORTLRX;
  1988.     TGEsys->_fillLine(yCoord, xCoord1, xCoord2, colour);
  1989.   }
  1990.  
  1991.   yCoord = yc + y;
  1992.   if (yCoord>=VIEWPORTULY && yCoord<=VIEWPORTLRY)
  1993.   {
  1994.     if (xCoord1 < VIEWPORTULX)        /* clip xCoord1 horizontally */
  1995.       xCoord1 = VIEWPORTULX;
  1996.     else if (xCoord1 > VIEWPORTLRX)
  1997.       xCoord1 = VIEWPORTLRX;
  1998.     if (xCoord2 < VIEWPORTULX)        /* clip xCoord2 horizontally */
  1999.       xCoord2 = VIEWPORTULX;
  2000.     else if (xCoord2 > VIEWPORTLRX)
  2001.       xCoord2 = VIEWPORTLRX;
  2002.     TGEsys->_fillLine(yCoord, xCoord1, xCoord2, colour);
  2003.   }
  2004. }
  2005.  
  2006.  
  2007. /***
  2008. **** circle
  2009. ***/
  2010. void TGE_circle(int x, int y, int radius, unsigned colour)
  2011. {
  2012.   TGEsys->_ellipse(x, y, 2*radius, (2*radius*(4*YRATIO))/(3*XRATIO), colour);
  2013. }
  2014.  
  2015.  
  2016. /***
  2017. **** filledCircle
  2018. ***/
  2019. void TGE_filledCircle(int x, int y, int radius, unsigned colour)
  2020. {
  2021.   TGEsys->_filledEllipse(x, y, 2*radius, (2*radius*(4*YRATIO))/(3*XRATIO), colour);
  2022. }
  2023.  
  2024.  
  2025. /***
  2026. **** fillRegion
  2027. ***/
  2028. static struct params {
  2029.   int x, y;
  2030. };
  2031. static unsigned regionColour, fillColour;
  2032. static int okToPush;
  2033. static struct params huge *stack;
  2034. static unsigned long stackSize, stackPtr;
  2035.  
  2036. void TGE_fillRegion(int seedX, int seedY, unsigned colour)
  2037. {
  2038.   struct params holder;
  2039.   register int x, v;
  2040.   int xl, xr, y;
  2041.  
  2042.   if (!TGE_clipPoint(seedX, seedY))        /* abort if seed point */
  2043.     return;                    /* is outside viewport */
  2044.  
  2045.   regionColour = TGEsys->_getPixel(seedX, seedY); /* initialize variables */
  2046.   if (regionColour == colour)
  2047.     return;
  2048.   fillColour = colour;
  2049.  
  2050.   stackSize = farcoreleft();            /* grab a very large */
  2051.   (void*)stack = farmalloc(stackSize);        /*  stack buffer     */
  2052.   stackSize /= sizeof(struct params);
  2053.   stackPtr = 0;
  2054.  
  2055.   okToPush = 1;
  2056.   holder.x = seedX;            /* push initial parameters */
  2057.   holder.y = seedY;
  2058.   stack[stackPtr] = holder;
  2059.   stackPtr++;
  2060.  
  2061.   while (stackPtr && stackPtr<=stackSize)    /* main loop */
  2062.   {
  2063.     stackPtr--;
  2064.     holder = stack[stackPtr];
  2065.  
  2066.     xl = xr = holder.x;
  2067.     y = holder.y;
  2068.  
  2069.     x = xl;                    /* scan left */
  2070.     if (x > VIEWPORTULX)
  2071.     {
  2072.       do
  2073.       {
  2074.     x--;
  2075.     v = TGEsys->_getPixel(x, y);
  2076.       }
  2077.       while ((v==regionColour) && (v!=fillColour) && (x>=VIEWPORTULX));
  2078.       x++;
  2079.       xl = x;
  2080.     }
  2081.  
  2082.     x = xr;                    /* scan right */
  2083.     if (x <= VIEWPORTLRX)
  2084.     {
  2085.       do
  2086.       {
  2087.     x++;
  2088.     v = TGEsys->_getPixel(x, y);
  2089.       }
  2090.       while ((v==regionColour) && (v!=fillColour) && (x<=VIEWPORTLRX));
  2091.       x--;
  2092.       xr = x;
  2093.     }
  2094.  
  2095.     TGEsys->_fillLine(y, xl, xr, fillColour);    /* fill the line */
  2096.  
  2097.     /* scan upwards */
  2098.     if (y > VIEWPORTULY)
  2099.     {
  2100.       for (x=xl; x<=xr; x++)
  2101.       {
  2102.     v = TGEsys->_getPixel(x, y-1);
  2103.     if (v==regionColour && okToPush)
  2104.     {
  2105.       holder.x = x;
  2106.       holder.y = y-1;
  2107.       stack[stackPtr] = holder;
  2108.       stackPtr++;
  2109.       if (stackPtr != stackSize)
  2110.       {
  2111.         do
  2112.         {
  2113.           x++;
  2114.           v = TGEsys->_getPixel(x, y-1);
  2115.         }
  2116.         while (v==regionColour && x<=xr);
  2117.         x--;
  2118.       }
  2119.       else
  2120.         okToPush = 0;
  2121.     }
  2122.       }
  2123.     }
  2124.  
  2125.     /* scan downwards */
  2126.     if (y < VIEWPORTLRY)
  2127.     {
  2128.       for (x=xl; x<=xr; x++)
  2129.       {
  2130.     v = TGEsys->_getPixel(x, y+1);
  2131.     if (v==regionColour && okToPush)
  2132.     {
  2133.       holder.x = x;
  2134.       holder.y = y+1;
  2135.       stack[stackPtr] = holder;
  2136.       stackPtr++;
  2137.       if (stackPtr != stackSize)
  2138.       {
  2139.         do
  2140.         {
  2141.           x++;
  2142.           v = TGEsys->_getPixel(x, y+1);
  2143.         }
  2144.         while (v==regionColour && x<=xr);
  2145.         x--;
  2146.       }
  2147.       else
  2148.         okToPush = 0;
  2149.     }
  2150.       }
  2151.     }
  2152.   };
  2153.  
  2154.   farfree((void far*)stack);            /* release stack memory */
  2155. }
  2156.  
  2157.  
  2158. /*****
  2159. ****** Viewport routines
  2160. *****/
  2161.  
  2162. void TGE_setViewports(int ulx, int uly, int lrx, int lry)
  2163. {
  2164.   disable();
  2165.   OUTVIEWPORTULX = ulx;                /* set values */
  2166.   INVIEWPORTULX  = ulx;
  2167.   OUTVIEWPORTULY = uly;
  2168.   INVIEWPORTULY  = uly;
  2169.   OUTVIEWPORTLRX = lrx;
  2170.   INVIEWPORTLRX  = lrx;
  2171.   OUTVIEWPORTLRY = lry;
  2172.   INVIEWPORTLRY  = lry;
  2173.   enable();
  2174. }
  2175.  
  2176. void TGE_setOutputViewport(int ulx, int uly, int lrx, int lry)
  2177. {
  2178.   disable();
  2179.   OUTVIEWPORTULX = ulx;                /* set values */
  2180.   OUTVIEWPORTULY = uly;
  2181.   OUTVIEWPORTLRX = lrx;
  2182.   OUTVIEWPORTLRY = lry;
  2183.   enable();
  2184. }
  2185.  
  2186. void TGE_setInputViewport(int ulx, int uly, int lrx, int lry)
  2187. {
  2188.   disable();
  2189.   INVIEWPORTULX = ulx;                /* set values */
  2190.   INVIEWPORTULY = uly;
  2191.   INVIEWPORTLRX = lrx;
  2192.   INVIEWPORTLRY = lry;
  2193.   enable();
  2194. }
  2195.  
  2196. void TGE_getOutputViewport(int far *ulx, int far *uly, int far *lrx, int far *lry)
  2197. {
  2198.   disable();
  2199.   *ulx = OUTVIEWPORTULX;            /* get values */
  2200.   *uly = OUTVIEWPORTULY;
  2201.   *lrx = OUTVIEWPORTLRX;
  2202.   *lry = OUTVIEWPORTLRY;
  2203.   enable();
  2204. }
  2205.  
  2206. void TGE_getInputViewport(int far *ulx, int far *uly, int far *lrx, int far *lry)
  2207. {
  2208.   disable();
  2209.   *ulx = INVIEWPORTULX;                /* get values */
  2210.   *uly = INVIEWPORTULY;
  2211.   *lrx = INVIEWPORTLRX;
  2212.   *lry = INVIEWPORTLRY;
  2213.   enable();
  2214. }
  2215.  
  2216.  
  2217. /*****
  2218. ****** Calculate the address of a pixel in a virtual screen.
  2219. *****/
  2220.  
  2221. unsigned char far* near outPixelAddr(int x, int y)
  2222. {
  2223.   unsigned char huge *p;
  2224.   unsigned long offset;
  2225.  
  2226.   (void far*) p = OUTADDR;        /* calculate pixel address */
  2227.   offset = y;
  2228.   offset *= OUTSCREENWIDE;
  2229.   offset += x;
  2230.  
  2231.   while (offset > 0xFFFF)        /* add 'offset' to address */
  2232.   {
  2233.     p += 0xFFFF;
  2234.     offset -= 0xFFFF;
  2235.   }
  2236.   p += (unsigned)offset;
  2237.  
  2238.   return ((unsigned char far*) p);    /* return the address */
  2239. }
  2240.  
  2241. unsigned char far* near inPixelAddr(int x, int y)
  2242. {
  2243.   unsigned char huge *p;
  2244.   unsigned long offset;
  2245.  
  2246.   (void far*) p = INADDR;        /* calculate pixel address */
  2247.   offset = y;
  2248.   offset *= INSCREENWIDE;
  2249.   offset += x;
  2250.  
  2251.   while (offset > 0xFFFF)        /* add 'offset' to address */
  2252.   {
  2253.     p += 0xFFFF;
  2254.     offset -= 0xFFFF;
  2255.   }
  2256.   p += (unsigned)offset;
  2257.  
  2258.   return ((unsigned char far*) p);    /* return the address */
  2259. }
  2260.  
  2261.  
  2262. /*****
  2263. ****** Virtual/real screen switching
  2264. *****/
  2265.  
  2266. void far TGE_setGraphicsAddr(void far *addr)
  2267. {
  2268.   TGE_setGraphicsInputAddr(addr);        /* configure input */
  2269.   TGE_setGraphicsOutputAddr(addr);        /* configure output */
  2270. }
  2271.  
  2272. void far TGE_setGraphicsInputAddr(void far *addr)
  2273. {
  2274.   register unsigned wide, deep;
  2275.  
  2276.   if (addr != NULL)    /* make a virtual screen active */
  2277.   {
  2278.     wide = ((unsigned*)addr)[0];    /* get memory block dimensions */
  2279.     deep = ((unsigned*)addr)[1];
  2280.     INADDR = (char*) addr + 4;        /* store as active address */
  2281.     INSCREENWIDE = wide;        /* needed for virtual screens */
  2282.     INMAXX = wide - 1;            /* adjust current input */
  2283.     INMAXY = deep - 1;            /* screen dimensions    */
  2284.     TGE_setInputViewport(0, 0, wide-1, deep-1);    /* viewport */
  2285.     setInputFunctions(MEMORY);        /* update TGE's function pointers */
  2286.   }
  2287.   else            /* make the screen active */
  2288.   {
  2289.     INADDR = TGEsys->scrAddr;        /* revert to screen address */
  2290.     INSCREENWIDE = wide;        /* needed for virtual screens */
  2291.     INMAXX = SCREENMAXX;        /* restore screen dimensions */
  2292.     INMAXY = SCREENMAXY;
  2293.     TGE_setInputViewport(0, 0, INMAXX, INMAXY);    /* viewport */
  2294.     setInputFunctions(SCREEN);        /* update TGE's function pointers */
  2295.   }
  2296. }
  2297.  
  2298. void far TGE_setGraphicsOutputAddr(void far *addr)
  2299. {
  2300.   register unsigned wide, deep;
  2301.  
  2302.   if (addr != NULL)    /* make a virtual screen active */
  2303.   {
  2304.     wide = ((unsigned*)addr)[0];    /* get memory block dimensions */
  2305.     deep = ((unsigned*)addr)[1];
  2306.     OUTADDR = (char*) addr + 4;        /* store as active address */
  2307.     OUTSCREENWIDE = wide;        /* needed for virtual screens */
  2308.     OUTMAXX = wide - 1;            /* adjust current screen */
  2309.     OUTMAXY = deep - 1;            /* dimensions */
  2310.     TGE_setOutputViewport(0, 0, wide-1, deep-1); /* viewport */
  2311.     setOutputFunctions(MEMORY, curOutputMode);    /* update TGE's function pointers */
  2312.     curOutputDest = MEMORY;        /* store current destination */
  2313.   }
  2314.   else            /* make the screen active */
  2315.   {
  2316.     OUTADDR = TGEsys->scrAddr;        /* revert to screen address */
  2317.     OUTSCREENWIDE = wide;        /* needed for virtual screens */
  2318.     OUTMAXX = SCREENMAXX;        /* restore screen dimensions */
  2319.     OUTMAXY = SCREENMAXY;
  2320.     TGE_setOutputViewport(0, 0, OUTMAXX, OUTMAXY); /* viewport */
  2321.     setOutputFunctions(SCREEN, curOutputMode);    /* update TGE's function pointers */
  2322.     curOutputDest = SCREEN;        /* store current destination */
  2323.   }
  2324. }
  2325.  
  2326. void far *TGE_getGraphicsOutputAddr(void)
  2327. {
  2328.   if (OUTADDR == SCRADDR)
  2329.     return (NULL);
  2330.   else
  2331.     return (OUTADDR);
  2332. }
  2333.  
  2334. void far *TGE_getGraphicsInputAddr(void)
  2335. {
  2336.   if (INADDR == SCRADDR)
  2337.     return (NULL);
  2338.   else
  2339.     return (INADDR);
  2340. }
  2341.  
  2342. void far *TGE_makeVirtScreen(unsigned wide, unsigned deep)
  2343. {
  2344.   void far *addr;
  2345.  
  2346.   if (wide && deep)            /* ensure wide>0 and deep>0 */
  2347.   {
  2348.     addr = farmalloc(TGEsys->_imageSizeDim(wide,deep));    /* allocate some RAM */
  2349.     if (addr == NULL)
  2350.       return (NULL);
  2351.     else
  2352.     {
  2353.       ((unsigned*)addr)[0] = wide;    /* store image width */
  2354.       ((unsigned*)addr)[1] = deep;    /* store image depth */
  2355.       return (addr);            /* return the address */
  2356.     }
  2357.   }
  2358.   else
  2359.     return (NULL);
  2360. }
  2361.  
  2362.  
  2363. /*****
  2364. ****** Change the current output mode
  2365. *****/
  2366.  
  2367. void TGE_setOutputMode(int mode)
  2368. {
  2369.   curOutputMode = mode;                /* store as current mode */
  2370.   setOutputFunctions(curOutputDest, mode);    /* setup for the new mode */
  2371. }
  2372.  
  2373.  
  2374. /*****
  2375. ****** Update function pointers given output mode and destination.
  2376. *****/
  2377.  
  2378. void near setInputFunctions(int memOrScreen)
  2379. {
  2380.   if (memOrScreen == MEMORY)    /* set virtual screen active */
  2381.   {
  2382.     TGEsys->_getImage      = TGEsys->_getImage_mem;     /* getImage      */
  2383.     TGEsys->_getLine       = TGEsys->_getLine_mem;     /* getLine       */
  2384.     TGEsys->_getPixel      = TGEsys->_getPixel_mem;     /* getPixel      */
  2385.   }
  2386.   else                /* set real screen active */
  2387.   {
  2388.     TGEsys->_getImage      = TGEsys->_getImage_scr;     /* getImage      */
  2389.     TGEsys->_getLine       = TGEsys->_getLine_scr;     /* getLine       */
  2390.     TGEsys->_getPixel      = TGEsys->_getPixel_scr;     /* getPixel      */
  2391.   }
  2392. }
  2393.  
  2394. void near setOutputFunctions(int memOrScreen, int writeMode)
  2395. {
  2396.   if (memOrScreen == MEMORY)    /* set virtual screen active */
  2397.   {
  2398.     switch (writeMode)
  2399.     {
  2400.       case TGE_COPY_PUT:    /* output using COPY */
  2401.     TGEsys->_putImage      = TGEsys->_putImage_mem_copy;      /* putImage      */
  2402.     TGEsys->_putImageInv   = TGEsys->_putImageInv_mem_copy;      /* putImageInv   */
  2403.     TGEsys->_putLine       = TGEsys->_putLine_mem_copy;      /* putLine       */
  2404.     TGEsys->_putLineInv    = TGEsys->_putLineInv_mem_copy;      /* putLineInv    */
  2405.     TGEsys->_putPixel      = TGEsys->_putPixel_mem_copy;      /* putPixel      */
  2406.     TGEsys->_line          = TGEsys->_line_mem_copy;      /* line          */
  2407.     TGEsys->_horizLine     = TGEsys->_horizLine_mem_copy;     /* horizLine     */
  2408.     TGEsys->_vertLine      = TGEsys->_vertLine_mem_copy;         /* vertLine      */
  2409.     TGEsys->_drawRect      = TGEsys->_drawRect_mem_copy;      /* drawRect      */
  2410.     TGEsys->_filledRect    = TGEsys->_filledRect_mem_copy;    /* filledRect    */
  2411.     TGEsys->_clearGraphics = TGEsys->_clearGraphics_mem_copy; /* clearGraphics */
  2412.     TGEsys->_ellipse       = TGEsys->_ellipse_mem_copy;      /* ellipse       */
  2413.     TGEsys->_filledEllipse = TGEsys->_filledEllipse_mem_copy; /* filledEllipse */
  2414.     TGEsys->_circle        = TGEsys->_circle_mem_copy;      /* circle        */
  2415.     TGEsys->_filledCircle  = TGEsys->_filledCircle_mem_copy;  /* filledCircle  */
  2416.     TGEsys->_fillRegion    = TGEsys->_fillRegion_mem_copy;      /* fillRegion    */
  2417.     TGEsys->_fillLine      = TGEsys->_fillLine_mem_copy;      /* fillLine      */
  2418.     break;
  2419.       case TGE_AND_PUT:        /* output using AND */
  2420.     TGEsys->_putImage      = TGEsys->_putImage_mem_and;      /* putImage      */
  2421.     TGEsys->_putImageInv   = TGEsys->_putImageInv_mem_and;      /* putImageInv   */
  2422.     TGEsys->_putLine       = TGEsys->_putLine_mem_and;      /* putLine       */
  2423.     TGEsys->_putLineInv    = TGEsys->_putLineInv_mem_and;      /* putLineInv    */
  2424.     TGEsys->_putPixel      = TGEsys->_putPixel_mem_and;      /* putPixel      */
  2425.     TGEsys->_line          = TGEsys->_line_mem_and;          /* line          */
  2426.     TGEsys->_horizLine     = TGEsys->_horizLine_mem_and;      /* horizLine     */
  2427.     TGEsys->_vertLine      = TGEsys->_vertLine_mem_and;         /* vertLine      */
  2428.     TGEsys->_drawRect      = TGEsys->_drawRect_mem_and;      /* drawRect      */
  2429.     TGEsys->_filledRect    = TGEsys->_filledRect_mem_and;        /* filledRect    */
  2430.     TGEsys->_clearGraphics = TGEsys->_clearGraphics_mem_and;  /* clearGraphics */
  2431.     TGEsys->_ellipse       = TGEsys->_ellipse_mem_and;      /* ellipse       */
  2432.     TGEsys->_filledEllipse = TGEsys->_filledEllipse_mem_and;  /* filledEllipse */
  2433.     TGEsys->_circle        = TGEsys->_circle_mem_and;      /* circle        */
  2434.     TGEsys->_filledCircle  = TGEsys->_filledCircle_mem_and;      /* filledCircle  */
  2435.     TGEsys->_fillRegion    = TGEsys->_fillRegion_mem_and;      /* fillRegion    */
  2436.     TGEsys->_fillLine      = TGEsys->_fillLine_mem_and;      /* fillLine      */
  2437.     break;
  2438.       case TGE_NOT_PUT:        /* output using NOT */
  2439.     TGEsys->_putImage      = TGEsys->_putImage_mem_not;      /* putImage      */
  2440.     TGEsys->_putImageInv   = TGEsys->_putImageInv_mem_not;      /* putImageInv   */
  2441.     TGEsys->_putLine       = TGEsys->_putLine_mem_not;      /* putLine       */
  2442.     TGEsys->_putLineInv    = TGEsys->_putLineInv_mem_not;      /* putLineInv    */
  2443.     TGEsys->_putPixel      = TGEsys->_putPixel_mem_not;      /* putPixel      */
  2444.     TGEsys->_line          = TGEsys->_line_mem_not;          /* line          */
  2445.     TGEsys->_horizLine     = TGEsys->_horizLine_mem_not;      /* horizLine     */
  2446.     TGEsys->_vertLine      = TGEsys->_vertLine_mem_not;         /* vertLine      */
  2447.     TGEsys->_drawRect      = TGEsys->_drawRect_mem_not;      /* drawRect      */
  2448.     TGEsys->_filledRect    = TGEsys->_filledRect_mem_not;        /* filledRect    */
  2449.     TGEsys->_clearGraphics = TGEsys->_clearGraphics_mem_not;  /* clearGraphics */
  2450.     TGEsys->_ellipse       = TGEsys->_ellipse_mem_not;      /* ellipse       */
  2451.     TGEsys->_filledEllipse = TGEsys->_filledEllipse_mem_not;  /* filledEllipse */
  2452.     TGEsys->_circle        = TGEsys->_circle_mem_not;      /* circle        */
  2453.     TGEsys->_filledCircle  = TGEsys->_filledCircle_mem_not;      /* filledCircle  */
  2454.     TGEsys->_fillRegion    = TGEsys->_fillRegion_mem_not;      /* fillRegion    */
  2455.     TGEsys->_fillLine      = TGEsys->_fillLine_mem_not;      /* fillLine      */
  2456.     break;
  2457.       case TGE_OR_PUT:        /* output using OR */
  2458.     TGEsys->_putImage      = TGEsys->_putImage_mem_or;      /* putImage      */
  2459.     TGEsys->_putImageInv   = TGEsys->_putImageInv_mem_or;      /* putImageInv   */
  2460.     TGEsys->_putLine       = TGEsys->_putLine_mem_or;      /* putLine       */
  2461.     TGEsys->_putLineInv    = TGEsys->_putLineInv_mem_or;      /* putLineInv    */
  2462.     TGEsys->_putPixel      = TGEsys->_putPixel_mem_or;      /* putPixel      */
  2463.     TGEsys->_line          = TGEsys->_line_mem_or;          /* line          */
  2464.     TGEsys->_horizLine     = TGEsys->_horizLine_mem_or;       /* horizLine     */
  2465.     TGEsys->_vertLine      = TGEsys->_vertLine_mem_or;         /* vertLine      */
  2466.     TGEsys->_drawRect      = TGEsys->_drawRect_mem_or;      /* drawRect      */
  2467.     TGEsys->_filledRect    = TGEsys->_filledRect_mem_or;        /* filledRect    */
  2468.     TGEsys->_clearGraphics = TGEsys->_clearGraphics_mem_or;      /* clearGraphics */
  2469.     TGEsys->_ellipse       = TGEsys->_ellipse_mem_or;      /* ellipse       */
  2470.     TGEsys->_filledEllipse = TGEsys->_filledEllipse_mem_or;      /* filledEllipse */
  2471.     TGEsys->_circle        = TGEsys->_circle_mem_or;      /* circle        */
  2472.     TGEsys->_filledCircle  = TGEsys->_filledCircle_mem_or;      /* filledCircle  */
  2473.     TGEsys->_fillRegion    = TGEsys->_fillRegion_mem_or;      /* fillRegion    */
  2474.     TGEsys->_fillLine      = TGEsys->_fillLine_mem_or;      /* fillLine      */
  2475.     break;
  2476.       case TGE_XOR_PUT:        /* output using XOR */
  2477.     TGEsys->_putImage      = TGEsys->_putImage_mem_xor;      /* putImage      */
  2478.     TGEsys->_putImageInv   = TGEsys->_putImageInv_mem_xor;      /* putImageInv   */
  2479.     TGEsys->_putLine       = TGEsys->_putLine_mem_xor;      /* putLine       */
  2480.     TGEsys->_putLineInv    = TGEsys->_putLineInv_mem_xor;      /* putLineInv    */
  2481.     TGEsys->_putPixel      = TGEsys->_putPixel_mem_xor;      /* putPixel      */
  2482.     TGEsys->_line          = TGEsys->_line_mem_xor;          /* line          */
  2483.     TGEsys->_horizLine     = TGEsys->_horizLine_mem_xor;      /* horizLine     */
  2484.     TGEsys->_vertLine      = TGEsys->_vertLine_mem_xor;         /* vertLine      */
  2485.     TGEsys->_drawRect      = TGEsys->_drawRect_mem_xor;      /* drawRect      */
  2486.     TGEsys->_filledRect    = TGEsys->_filledRect_mem_xor;        /* filledRect    */
  2487.     TGEsys->_clearGraphics = TGEsys->_clearGraphics_mem_xor;  /* clearGraphics */
  2488.     TGEsys->_ellipse       = TGEsys->_ellipse_mem_xor;      /* ellipse       */
  2489.     TGEsys->_filledEllipse = TGEsys->_filledEllipse_mem_xor;  /* filledEllipse */
  2490.     TGEsys->_circle        = TGEsys->_circle_mem_xor;      /* circle        */
  2491.     TGEsys->_filledCircle  = TGEsys->_filledCircle_mem_xor;      /* filledCircle  */
  2492.     TGEsys->_fillRegion    = TGEsys->_fillRegion_mem_xor;      /* fillRegion    */
  2493.     TGEsys->_fillLine      = TGEsys->_fillLine_mem_xor;      /* fillLine      */
  2494.     break;
  2495.       default:
  2496.     ;
  2497.     }
  2498.   }
  2499.   else                /* set real screen active */
  2500.   {
  2501.     switch (writeMode)
  2502.     {
  2503.       case TGE_COPY_PUT:    /* output using COPY */
  2504.     TGEsys->_putImage      = TGEsys->_putImage_scr_copy;      /* putImage      */
  2505.     TGEsys->_putImageInv   = TGEsys->_putImageInv_scr_copy;      /* putImageInv   */
  2506.     TGEsys->_putLine       = TGEsys->_putLine_scr_copy;      /* putLine       */
  2507.     TGEsys->_putLineInv    = TGEsys->_putLineInv_scr_copy;      /* putLineInv    */
  2508.     TGEsys->_putPixel      = TGEsys->_putPixel_scr_copy;      /* putPixel      */
  2509.     TGEsys->_line          = TGEsys->_line_scr_copy;      /* line          */
  2510.     TGEsys->_horizLine     = TGEsys->_horizLine_scr_copy;     /* horizLine     */
  2511.     TGEsys->_vertLine      = TGEsys->_vertLine_scr_copy;         /* vertLine      */
  2512.     TGEsys->_drawRect      = TGEsys->_drawRect_scr_copy;      /* drawRect      */
  2513.     TGEsys->_filledRect    = TGEsys->_filledRect_scr_copy;    /* filledRect    */
  2514.     TGEsys->_clearGraphics = TGEsys->_clearGraphics_scr_copy; /* clearGraphics */
  2515.     TGEsys->_ellipse       = TGEsys->_ellipse_scr_copy;      /* ellipse       */
  2516.     TGEsys->_filledEllipse = TGEsys->_filledEllipse_scr_copy; /* filledEllipse */
  2517.     TGEsys->_circle        = TGEsys->_circle_scr_copy;      /* circle        */
  2518.     TGEsys->_filledCircle  = TGEsys->_filledCircle_scr_copy;  /* filledCircle  */
  2519.     TGEsys->_fillRegion    = TGEsys->_fillRegion_scr_copy;      /* fillRegion    */
  2520.     TGEsys->_fillLine      = TGEsys->_fillLine_scr_copy;      /* fillLine      */
  2521.     break;
  2522.       case TGE_AND_PUT:        /* output using AND */
  2523.     TGEsys->_putImage      = TGEsys->_putImage_scr_and;      /* putImage      */
  2524.     TGEsys->_putImageInv   = TGEsys->_putImageInv_scr_and;      /* putImageInv   */
  2525.     TGEsys->_putLine       = TGEsys->_putLine_scr_and;      /* putLine       */
  2526.     TGEsys->_putLineInv    = TGEsys->_putLineInv_scr_and;      /* putLineInv    */
  2527.     TGEsys->_putPixel      = TGEsys->_putPixel_scr_and;      /* putPixel      */
  2528.     TGEsys->_line          = TGEsys->_line_scr_and;          /* line          */
  2529.     TGEsys->_horizLine     = TGEsys->_horizLine_scr_and;      /* horizLine     */
  2530.     TGEsys->_vertLine      = TGEsys->_vertLine_scr_and;         /* vertLine      */
  2531.     TGEsys->_drawRect      = TGEsys->_drawRect_scr_and;      /* drawRect      */
  2532.     TGEsys->_filledRect    = TGEsys->_filledRect_scr_and;        /* filledRect    */
  2533.     TGEsys->_clearGraphics = TGEsys->_clearGraphics_scr_and;  /* clearGraphics */
  2534.     TGEsys->_ellipse       = TGEsys->_ellipse_scr_and;      /* ellipse       */
  2535.     TGEsys->_filledEllipse = TGEsys->_filledEllipse_scr_and;  /* filledEllipse */
  2536.     TGEsys->_circle        = TGEsys->_circle_scr_and;      /* circle        */
  2537.     TGEsys->_filledCircle  = TGEsys->_filledCircle_scr_and;      /* filledCircle  */
  2538.     TGEsys->_fillRegion    = TGEsys->_fillRegion_scr_and;      /* fillRegion    */
  2539.     TGEsys->_fillLine      = TGEsys->_fillLine_scr_and;      /* fillLine      */
  2540.     break;
  2541.       case TGE_NOT_PUT:        /* output using NOT */
  2542.     TGEsys->_putImage      = TGEsys->_putImage_scr_not;      /* putImage      */
  2543.     TGEsys->_putImageInv   = TGEsys->_putImageInv_scr_not;      /* putImageInv   */
  2544.     TGEsys->_putLine       = TGEsys->_putLine_scr_not;      /* putLine       */
  2545.     TGEsys->_putLineInv    = TGEsys->_putLineInv_scr_not;      /* putLineInv    */
  2546.     TGEsys->_putPixel      = TGEsys->_putPixel_scr_not;      /* putPixel      */
  2547.     TGEsys->_line          = TGEsys->_line_scr_not;          /* line          */
  2548.     TGEsys->_horizLine     = TGEsys->_horizLine_scr_not;      /* horizLine     */
  2549.     TGEsys->_vertLine      = TGEsys->_vertLine_scr_not;         /* vertLine      */
  2550.     TGEsys->_drawRect      = TGEsys->_drawRect_scr_not;      /* drawRect      */
  2551.     TGEsys->_filledRect    = TGEsys->_filledRect_scr_not;        /* filledRect    */
  2552.     TGEsys->_clearGraphics = TGEsys->_clearGraphics_scr_not;  /* clearGraphics */
  2553.     TGEsys->_ellipse       = TGEsys->_ellipse_scr_not;      /* ellipse       */
  2554.     TGEsys->_filledEllipse = TGEsys->_filledEllipse_scr_not;  /* TGEsys->_filledEllipse */
  2555.     TGEsys->_circle        = TGEsys->_circle_scr_not;      /* circle        */
  2556.     TGEsys->_filledCircle  = TGEsys->_filledCircle_scr_not;      /* filledCircle  */
  2557.     TGEsys->_fillRegion    = TGEsys->_fillRegion_scr_not;      /* fillRegion    */
  2558.     TGEsys->_fillLine      = TGEsys->_fillLine_scr_not;      /* fillLine      */
  2559.     break;
  2560.       case TGE_OR_PUT:        /* output using OR */
  2561.     TGEsys->_putImage      = TGEsys->_putImage_scr_or;      /* putImage      */
  2562.     TGEsys->_putImageInv   = TGEsys->_putImageInv_scr_or;      /* putImageInv   */
  2563.     TGEsys->_putLine       = TGEsys->_putLine_scr_or;      /* putLine       */
  2564.     TGEsys->_putLineInv    = TGEsys->_putLineInv_scr_or;      /* putLineInv    */
  2565.     TGEsys->_putPixel      = TGEsys->_putPixel_scr_or;      /* putPixel      */
  2566.     TGEsys->_line          = TGEsys->_line_scr_or;          /* line          */
  2567.     TGEsys->_horizLine     = TGEsys->_horizLine_scr_or;       /* horizLine     */
  2568.     TGEsys->_vertLine      = TGEsys->_vertLine_scr_or;         /* vertLine      */
  2569.     TGEsys->_drawRect      = TGEsys->_drawRect_scr_or;      /* drawRect      */
  2570.     TGEsys->_filledRect    = TGEsys->_filledRect_scr_or;        /* filledRect    */
  2571.     TGEsys->_clearGraphics = TGEsys->_clearGraphics_scr_or;      /* clearGraphics */
  2572.     TGEsys->_ellipse       = TGEsys->_ellipse_scr_or;      /* ellipse       */
  2573.     TGEsys->_filledEllipse = TGEsys->_filledEllipse_scr_or;      /* filledEllipse */
  2574.     TGEsys->_circle        = TGEsys->_circle_scr_or;      /* circle        */
  2575.     TGEsys->_filledCircle  = TGEsys->_filledCircle_scr_or;      /* filledCircle  */
  2576.     TGEsys->_fillRegion    = TGEsys->_fillRegion_scr_or;      /* fillRegion    */
  2577.     TGEsys->_fillLine      = TGEsys->_fillLine_scr_or;      /* fillLine      */
  2578.     break;
  2579.       case TGE_XOR_PUT:        /* output using XOR */
  2580.     TGEsys->_putImage      = TGEsys->_putImage_scr_xor;      /* putImage      */
  2581.     TGEsys->_putImageInv   = TGEsys->_putImageInv_scr_xor;      /* putImageInv   */
  2582.     TGEsys->_putLine       = TGEsys->_putLine_scr_xor;      /* putLine       */
  2583.     TGEsys->_putLineInv    = TGEsys->_putLineInv_scr_xor;      /* putLineInv    */
  2584.     TGEsys->_putPixel      = TGEsys->_putPixel_scr_xor;      /* putPixel      */
  2585.     TGEsys->_line          = TGEsys->_line_scr_xor;          /* line          */
  2586.     TGEsys->_horizLine     = TGEsys->_horizLine_scr_xor;      /* horizLine     */
  2587.     TGEsys->_vertLine      = TGEsys->_vertLine_scr_xor;         /* vertLine      */
  2588.     TGEsys->_drawRect      = TGEsys->_drawRect_scr_xor;      /* drawRect      */
  2589.     TGEsys->_filledRect    = TGEsys->_filledRect_scr_xor;        /* filledRect    */
  2590.     TGEsys->_clearGraphics = TGEsys->_clearGraphics_scr_xor;  /* clearGraphics */
  2591.     TGEsys->_ellipse       = TGEsys->_ellipse_scr_xor;      /* ellipse       */
  2592.     TGEsys->_filledEllipse = TGEsys->_filledEllipse_scr_xor;  /* filledEllipse */
  2593.     TGEsys->_circle        = TGEsys->_circle_scr_xor;      /* circle        */
  2594.     TGEsys->_filledCircle  = TGEsys->_filledCircle_scr_xor;      /* filledCircle  */
  2595.     TGEsys->_fillRegion    = TGEsys->_fillRegion_scr_xor;      /* fillRegion    */
  2596.     TGEsys->_fillLine      = TGEsys->_fillLine_scr_xor;      /* fillLine      */
  2597.     break;
  2598.       default:
  2599.     ;
  2600.     }
  2601.   }
  2602. }